HTX Arduino - Brugerbidrag [da]

Spole ved AC

2026-04-20T13:01:34Z

Bar: /* Faseforskydning */

[[Fil:Electronic_component_inductors.jpg|thumb]]

En spole vil prøve at forhindre enhver ændring i dens strøm. Sendes strøm igennem den vil den prøve at forhindre strømmen i at opstå, og modsat vil den forsøge at fastholde strømmen hvis den fjernes.

Denne evne kaldes for selvinduktion (L), som måles i Henry (H).

Vi vil se på en spole forbundet til en vekselspændingskilde:
Skruer vi ned for frekvensen vil strømmen stige og omvendt. Det er fordi under hyppige strømændringer vil spolen inducere en modsat spænding over sig, og altså forhindre strømmen i at ændre sig. Energien til dette får den ved at nedbryde sit magnetfelt.

'''Spolen yder en stigende modstand, ved stigende frekvens.'''

== Reaktans ==

Spolen optræder som en vekselstrømsmodstand også kaldet en reaktans (XL), som måles i ohm. Reaktansen er ligefrem proportional med frekvensen. Fordobles frekvensen, fordobles reaktansen.

En spole med større selvinduktion vil også få reaktansen til at stige:

'''XL = 2*π*f*L'''

Reaktansen for en ideel spole kan beregnes efter Ohms lov:

'''XL = uL/iL'''

== Faseforskydning ==
[[Fil:Spole_Faseforskydning.png|thumb]]

En spole har ligesom en kondensator også en faseforskydning imellem strøm og spænding. I Spolen kommer spændingen (e i figuren) 90° før strømmen (i i figuren), hvor det er omvendt i en kondensator. De 90° svarer til 1/4 af periodetiden.

'''Spændingen kommer 90° (1/4 periode) før strømmen.'''

Magnetfeltet er i fase med strømmen. Eftersom det er strømændringen, der får spolen til at inducere sin spolespænding ue, vil spændingen være størst når strømændringen er størst. Det er den lige ved nulskæringen, da kurven er stejlest netop der.

== Eksempel på udregning ==

For en spole på 0,1 H findes XL ved 100 Hz til:
'''XL = 2*π*f*L = 2*π*100Hz*0,1H = 62,8 Ω'''
Ved 1000 Hz vil XL blive 10 gange større. En spole på 1 H vil ligeledes have en 10 gange større modstand ved denne frekvens.

På en spole måles spænding og strøm til 3 V og 1,5 mA, ved frekvensen 1 kHz.
'''XL = u/i = 3V/1,5mA = 2 kΩ'''
Så findes selvinduktion:
'''XL = 2*π*f*L <=> L = XL/(2*π*f) = 2kΩ/(2*π*1kHz) = 0,32 H'''

== Spolens godhed ==
En spole er ofte viklet af kobbertråd, og vil derfor have en ohmsk modstand der afhænger af trådens tykkelse og længde. Kernen kan også yde andre tab. Samlet kaldes alle disse tab for spolens tabsmodstand '''r'''. På grund af denne tabsmodstand er fasedrejningen ikke længere 90gr (ikke en ideel spole).
Spolens godhed '''Q''', angiver forholdet imellem induktiv reaktans og tabsmodstanden.
'''Q = XL/r

== Selvinduktion ==

En [[:Kategori:spole|spole]]s selvinduktionen bestemmes af fire egenskaber:
*Spolens vindingers diameter
*Antallet af vindinger
*Spolens bredde
*Materialet der tjener som evt. "kerne" i spolen.

{{analog}}

[[Kategori:Spole]]
[[Kategori:Filtre]]

Arduino Transceiver modul

2025-12-31T23:17:04Z

Bar: /* Forbedring af rækkevidden */

[[Fil:2-4-transiver.jpg|thumb|right|300px|2.4 GHz Transceiver modul (NRF24L01)]]

NRF24L01 er et modul, der kan bruges til at sende og modtage data fra en microcontroller til en anden. 
Dette betyder, at modulet både kan bruges som transmitter og receiver. Men det skal dog stadigvæk have klare instrukser om, hvilket af de to stadier den skal være i, altså om den skal sende eller modtage, så derfor er to vejs kommunikation ikke så lige til, som f.eks. bluetooth er.

Selve modulet kører på 2.4 GHz båndet, hvilket er det samme som de fleste wifi kommunikationer. Modulet er i stand til at levere data med 2 Mbps, hvilket er forholdsvist meget, for en så lille og billig chip. 
Modulet har et meget lavt strømforbrug, da det maksimalt bruger 14 mA, samt har en "standby" funktion, hvilket bruger få µA. Dette gør modulet ideelt til projekter, som kører på batteri.

Uddybende information om modulet kan findes her <ref>[http://arduinoinfo.mywikis.net/wiki/Nrf24L01-2.4GHz-HowTo Uddybende information] om modulet på engelsk</ref>

Databladet for modulet kan findes på Nordic Semiconducter's hjemmeside <ref>[http://www.nordicsemi.com/eng/Products/2.4GHz-RF/nRF24L01 Datablad] fra producent</ref>

Modulet kan skaffes forskellige steder <ref>[http://www.miniinthebox.com/upgraded-2-4ghz-nrf24l01-wireless-transceiver-module-for-arduino-black_p683437.html Købsside] ved MiniInTheBox.com</ref> <ref>[https://www.aliexpress.com/item/DIP-NRF24L01-wireless-data-transmission-module-2-4G-NRF24L01-wireless-module/32817243166.html Købsside] ved aliexpress.com</ref>.

__FORCETOC__

== Uddybende information om NRF24L01 ==

=== Forskellige versioner ===
[[Fil:NRF24L01-ANT.jpg|thumb|right|200px|NRF24L01 med ekstern antenne]]

NRF24L01 modulerne, er en serie af billige RF moduler, baseret på "Nordic Semiconductor nRF24L01+" chippen.

De findes i flere forskellige versioner. Både med indbyggede antenner i printpladen (low-power version) og eksterne antenner (high-power version). De mest almindelige og billigste er dem med antennen indbygget i printpladen. Disse opnår dog ikke en rækkevidde, som er nær så lang som dem med eksterne antenner.

===Rækkevidde===

Modulerne med indbygget antenne, reklameres med at have en rækkevidde op til 100 meter. Dette er dog, under meget optimale forhold. Dette vil sige udenfor, uden nogen forhindringer og med en solid strømkilde. Derudover vil man heller ikke kunne bruge de fulde 2 Mbps, hvis man vil opnå så stor rækkevidde med low-power versionen. Indenfor vil man igennem mure kunne opnå ca. 10 meter. Der er dog visse ting, der kan gøre, for at gøre rækkevidden bedre. Dette vil der stå mere om, under afsnittet [[#Forbedring af rækkevidden|forbedring af rækkevidden]]

Med den eksterne antenne, vil man med nogle moduler kunne opnå en rækkevidde på op til 1 km.

{{#ev:youtube|gtM832Z0ujE|400}} 
[https://youtu.be/gtM832Z0ujE Her] ses en video af youtuberen "iforce2d", som laver en sammenligning af rækkevidden på nogle forskellige moduler:

Han har også lavet et forsøg, hvor han formåede at få en rækkevidde på over 31 km, med et NRF24L01 modul, med en stor antenne. Det er ca den samme afstand, som der er fra Holstebro og til Herning.

== Brug af NRF24L01 ==

===Biblioteker===
Der findes flere forskellige biblioteker til modulet, som alle sammen gør det meget nemmer at benytte det ellers meget komplekse modul. Det mest udførlige, samt det bibliotek der vil blive brugt i eksemplerne er TMRh20's RF24 bibliotek. Det kan findes i Arduinoens IDE under Sketch - Include Library - Manage Libraries... Søg der efter "RF24" og led efter biblioteket fra TMRh20. Eller download biblioteket fra github. <ref>[http://tmrh20.github.io/RF24/ TMRh20's RF24 bibliotek] på Github</ref>

=== Opkobling af modul (Hardware) ===
Det er meget vigtigt, at være klar over, at modulet kører på 3.3V(1.9 til 3.6V) og ikke 5V, som ellers er normalt for de fleste arduino moduler! Heldigvis er alle data benene 5V tolerante, hvilket betyder, at de kan kobles direkte op til arduinoens data pins.

Det kan være besværligt, at finde ud af, hvilke pins der skal hvortil første gang man bruger modulet, men en let måde at kende det på, er ved at kigge efter den firkantede solder pad. Dette er pin 1, hvorefter de tæller opad i 4 rækker. 
Dette billede viser modulet set oppefra. 
[[Fil:24L01Pinout.jpg|700px]]

Det er muligt at ændre på de to pins CE og CSN i programmet man skriver, hvilket vil sige, at de kan bruges på andre pins i stedet. Men SCK, MOSI og MISO er bestemt efter, hvilke pins modulet, som man kobler sin NRF op til, bruger til SPI kommunikation.

Der er en del forskellige måder at koble modulet op, alt efter hvilket library man bruger.
{|class="wikitable"
|-
!Ben!!Navn!!Note!!TMRh20-RF24!!RF24!!Mirf!!RH_NRF24!!RF24(Mega)!!RH_NRF24(Mega)
|-
|1||GND||Stel||GND||GND||GND||GND||GND||GND
|-
|2||VCC||3.3V!||3.3V*||3.3V*||3.3V*||3.3V*||3.3V*||3.3V*
|-
|3||CE||-||7||9||8||8||9||8
|-
|4||CSN||-||8||10||7||10||53||53
|-
|5||SCK||-||13||13||13||13||52||52
|-
|6||MOSI||-||11||11||11||11||51||51
|-
|7||MISO||-||12||12||12||12||50||50
|-
|8||IRQ||-||-**||2||-**||-**||2||-**
|}

Hvis man bruger TMRh20's bibliotek, kan andre moduler kobles op på følgende måde:

{|class="wikitable"
|-
!Ben!!Navn!!Note!!Arduino UNO!!Arduino Mega!!ATtiny25/45/85!!ATtiny44/84!!RPi
|-
|1||GND||Stel||GND||GND||pin 4||pin 14||RPi-GND
|-
|2||VCC||3.3V!||3.3V*||3.3V*||pin 8||pin 1||RPi-3v3
|-
|3||CE||-||7||7||pin 2||pin 12||RPi-GPIO22
|-
|4||CSN||-||8||8||pin 3||pin 11||RPi-GPIO8
|-
|5||SCK||-||13||52||pin 7||pin 9||RPi-sckl
|-
|6||MOSI||-||11||51||pin 6||pin 7||RPi-mosi
|-
|7||MISO||-||12||50||pin 5||pin 8||RPi-miso
|-
|8||IRQ||-||-**||-**||-**||-**||-**
|}
Bemærk! Ved de to arduino boards, bliver der refereret til deres digitale outputs, mens de to ATtiny chips, refererer til deres respektive pins på selve microcontrolleren.

* Grunden til mange problemer med modulet, er at arduinoens indbyggede 3.3V ikke kan give så meget strøm, som modulet har brug for under de meget korte sendinger af data. Arduino Mega'en er det største problem. Læs mere om dette problem, og hvordan man løser det under [[#Forbedring af rækkevidden|forbedring af rækkevidden]] 
Dette betyder ikke, at man ikke kan bruge de indbyggede 3.3V fra arduinoen. Man kan bare ikke forvente lige så gode resultater. 

** Det er ikke alle biblioteker, der benytter sig af IRQ, men RF24 biblioteket benytter sig af det i nogle eksempler. 

=== Sending af data (Software) ===
==== Kommandoer ====
Der findes et hav af kommandoer til dette modul, som alle kan findes på TMRH20's side for modulet. <ref>[https://tmrh20.github.io/RF24/classRF24.html Liste] over kommandoer for modulet</ref>
Dog vil der kun blive gennemgået de basale, så det er muligt at få modulet op at køre.

Det først der skal gøres, er at starte en ny radio. Dette skal gøres både på afsender og modtager modulet. I dette tilfælde kalder vi den bare "radio", men den kan også hedde hvad som helst andet. Det er også her vi definerer hvilke pins, der skal bruges til hhv. CE og CS.
<source lang="C">
//Overordnet definition af kommando:
RF24 nameOfRadio(CEPIN, CSPIN); //nameOfRadio kan udskiftes med lige hvad man vil, og bruges i andre kommandoer, når man bruger modulet. uint8_t _cepin og uint8_t _cspin bestemmer hvilke pins man bruger som hhv. CE og CS pins.
//Eksempel:
RF24 radio(7,8); //I vores eksempel kalder vi radioen for radio og vi bruger pin 7 som CE og pin 8 som CS.
</source>

Nu hvor vi har kaldt vores radio "radio", skal dette indgå i kommandoer, når vi bruger modulet. Dette gøre ved at skrive "radio" efterfulgt af et punktum, og derefter kommandoen man vil udføre.

For at kunne benytte vores modul, skal det først startes. Dette gøres med med følgende kommando:
<source lang="C">
//Overordnet definition af kommando:
nameOfRadio.begin(); //Indsæt navnet på din radio på nameOfRadio's plads
//Eksempel:
radio.begin(); //I dette tilfælde benytter vi vores navn "radio", som valgte i kommandoen ovenfor.
</source>

Det er også muligt at indstille hastigheden, hvorved modulet overfører data til et andet modul. Grunden til, at dette er brugbart, forklares i sektionen med [[#Forbedring af rækkevidden|forbedring af rækkevidden]]. For at indstille hastigheden, skal følgende kommando bruges:
<source lang="C">
//Overordnet definition af kommando:
nameOfRadio.setDataRate(RF24_DATARATE); //I parenteserne, skal datahastigheden indsættes. Der er 3 forskellige muligheder.
//Eksempel:
radio.setDataRate(RF24_250KBPS); //Sæt data hastigheden til 250 Kbps, for at opnå maksimal rækkevidde.
radio.setDataRate(RF24_1MBPS); //Sæt data hastigheden til 1 Mbps, for at opnå middel hastighed og rækkevidde.
radio.setDataRate(RF24_2MBPS); //Sæt data hastigheden til 2 Mbps, for at opnå maksimal hastighed.
</source>

Derudover er det også muligt at indstille, hvor meget strøm modulet bruger. Brugbarhede naf dette forklares under [[#Forbedring af rækkevidden|forbedring af rækkevidden]]. For at benytte sig af funktionen, benyttes følgende kommando:
<source lang="C">
//Overordnet definition af kommando:
nameOfRadio.setPALevel(RF24_POWER); //I parenteserne, skal strømniveauet af modulet sættes til et af de 4 følgende værdier.
//Eksempel:
radio.setPALevel(RF24_PA_MIN); //Sæt strømniveauet for modulet til det minimale
radio.setPALevel(RF24_PA_LOW); //Sæt strømniveauet for modulet til lav
radio.setPALevel(RF24_PA_HIGH); //Sæt strømniveauet for modulet til høj
radio.setPALevel(RF24_PA_MAX); //Sæt strømniveauet for modulet til det maksimale
</source>

Der skal vælges en kanal, som de moduler kan snakke over. Det er vigtigt, at den kanal man bruger, ikke bliver brugt af alt muligt andet udstyr, som kan lave interferens. Denne kanal kan gå fra 0 til 124, så det vil sige 125 forskellige kanaler. Under [[#Forbedring af rækkevidden|forbedring af rækkevidden]] står der mere om, hvorfor det er vigtigt at vælge den rigtige kanal. Kommandoen fungerer som følger:
<source lang="C">
//Overordnet definition af kommando:
nameOfRadio.setChannel(CHANNEL_NUMBER); //Kanalen sættes til et tal mellem 0 og 124.
//Eksempel:
radio.setChannel(108); //I dette eksempel sættes kanalen til 108.
</source>

For at kommunikerer imellem de to moduler, skal der først laves et "rør" (pipe), som de to moduler kan snakke igennem. Dette rør, skal have en fælles adresse, kanal og datahastighed, for at de to moduler kan snakke sammen.

For at sende informationer, skal der åbnes et "skrive rør" (writing pipe). Dette gøres ved først at definere en adresse, og derefter lave et "skrive rør" med denne adresse på sendermodulet:
<source lang="C">
//Overordnet definition af kommando:
byte addresses[][6] = {ADDRESS}; //Indsæt den valgte adresse i ADDRESS.
nameOfRadio.openWritingPipe(addresses[0]); //Her er adressen indsat i kommandoen.
//Eksempel:
byte addresses[][6] = {"0"}; //I dette eksempel er adressen sat til "0".
radio.openWritingPipe(addresses[0]); //Adressen er indsat i kommandoen
</source>

Nu skal der tilsvarende også være et "læse rør" (reading pipe). Dette gøres på næsten samme måde, som med "skrive røret". Den eneste forskel er, at der skal et tal ind som en anden parameter i kommandoen. Følgende kommando skal stå i koden for modtagermodulet:
<source lang="C">
//Overordnet definition af kommando:
byte addresses[][6] = {ADDRESS}; //Indsæt den valgte adresse i ADDRESS.
nameOfRadio.openReadingPipe(1, addresses[0]); //Her er tallet 1, samt adressen indsat i kommandoen.
//Eksempel:
byte addresses[][6] = {"0"}; //I dette eksempel er adressen sat til "0".
radio.openReadingPipe(1, addresses[0]); //Her er tallet 1, samt adressen indsat i kommandoen.
</source>

En anden meget vigtig kommando for modtager modulet er kommandoen der får modulet til at lytte:
<source lang="C">
//Overordnet definition af kommando:
nameOfRadio.startListening(); //Får modulet til at begynde at lytte.
//Eksempel:
radio.startListening(); //Får modulet til at begynde at lytte.
</source>

For at sende noget til det andet modul, skal bestemme hvad for noget data der skal sendes, og hvor stor dataet er:
<source lang="C">
//Overordnet definition af kommando:
nameOfRadio.write(&DATA, sizeof(SIZE_OF_DATA); //Den første parameter skal være et & tegn, efterfulgt af det data der skal sendes, og den anden parameter skal være størrelsen af den type data.
//Eksempel:
int test = 42; //42 bliver gemt i variablen test.
radio.write(&test, sizeof(int); //42 bliver sendt, ved at sætte et & tegn foran variablen test's navn. Den anden parameter er størrelsen på en int.
</source>

For at modtage data fra det andet modul, skal der gøres stort set det samme.
<source lang="C">
//Overordnet definition af kommando:
nameOfRadio.read(&DATA, sizeof(SIZE_OF_DATA); //Den første parameter skal være et & tegn, efterfulgt af det data der skal modtages, og den anden parameter skal være størrelsen af den type data.
//Eksempel:
int test; //Der allokeres plads til en int ved navn test,
radio.read(&test, sizeof(int); // Der bliver modtaget noget og gemt i variablen test.
</source>

Dette er alle kommandoer der skal til, for at opbygge en simpel et vejs kommunikation. For at lave mere avancerede programmer, kan man bruge den fulde liste af kommandoer, samt nogle af de andre [[#Referencer|referencer]] der er linket til i bunden af siden.

==== Eksempel ====
Dette er et eksempel på et meget simpelt program, der sender noget data i en pakke fra et modul til et andet. Koden er skrevet af "educ8s.tv", som også har lavet en kort video, som forklarer de grundlæggende ting ved modulet.<ref>[http://educ8s.tv/nrf24l01/ educ8s.tv's hjemmeside] om NRF24L01</ref>
Koden til modulet, samt biblioteket på daværende tidspunkt kan findes [[:File:nrf24l01eksempel.zip|her]]

Sender modul:
<source lang="C">
#include <SPI.h> //Der skal bruges SPI for at kommunikere med modult.
#include "RF24.h" //Biblioteket for modulet tages i brug.

RF24 myRadio (7, 8); //Der laves en radio ved navn "myRadio", der benytter sig af pin 7 og 8.
byte addresses[][6] = {"0"}; //Adressen "0" benyttes til at kommunikere.

struct package //Der laves en struktur med data i.
{
int id = 1; //Nummer på pakken der bliver sendt.
float temperature = 18.3; //Fiktiv temperatur, der illustrerer at man kan sende flere forskellige typer af data på en gang.
char text[100] = "Text to be transmitted"; //Tekst der bliver sendt med hver pakke.
};

typedef struct package Package;
Package data; //Pakken bliver kaldt "data"

void setup()
{
Serial.begin(115200); //Der startes en seriel kommunikation med en båndbredde på 115200.
delay(1000); //Der er et delay på 1 sekund.
myRadio.begin(); //Radioen ved navn "myRadio" startes.
myRadio.setChannel(115); //Kanalen bliver sat til 115
myRadio.setPALevel(RF24_PA_MAX); //Strømniveauet for modulet bliver sat til MAX. (Dette gøres kun, da der bliver brugt en solid strømkilde.)
myRadio.setDataRate(RF24_250KBPS) ; //Båndbredden bliver sat til 250 KBPS, da der ikke skal bruges mere end det, for at sende de 3 typer data.
myRadio.openWritingPipe(addresses[0]); //Der startes et "skrive rør" med adressen, som blev sat til 0 tidligere.
delay(1000); //Endnu et delay på 1 sekund.
}

void loop()
{
myRadio.write(&data, sizeof(data)); //Pakken ved navn data bliver afsendt.

Serial.print("\nPackage:"); //Et linjeskift efterfulgt af "Package:" bliver skrevet til den serielle monitor.
Serial.println(data.id); //Id i pakken data bliver skrevet til den serielle monitor.
Serial.println(data.temperature); //Den fiktive temperatur bliver skrevet til den serielle monitor.
Serial.println(data.text); //Teksten bliver skrevet til den serielle monitor.
data.id++; //Id i pakken data bliver gjort 1 større.
data.temperature += 0.1; //Den fiktive temperatur bliver gjort 0.1 større.
delay(1000); //Der ventes i 1 sekund.

}
</source>

Modtager modul
<source lang="C">
#include <SPI.h> //Der skal bruges SPI for at kommunikere med modult.
#include "RF24.h" //Biblioteket for modulet tages i brug.

RF24 myRadio (7, 8); //Der laves en radio ved navn "myRadio", der benytter sig af pin 7 og 8.

byte addresses[][6] = {"0"}; //Adressen "0" benyttes til at kommunikere.

struct package //Der laves en struktur med data i
{
int id; //Der gøres plads til en int ved navn "id"
float temperature; //Der gøres plads til en float ved navn "temperature"
char text[100]; //Der gøres plads til en char ved navn "text"
};

typedef struct package Package;
Package data; //Pakken bliver kaldt "data"

void setup()
{
Serial.begin(115200); //Der startes en seriel kommunikation med en båndbredde på 115200.
delay(1000); //Der er et delay på 1 sekund.
myRadio.begin(); //Radioen ved navn "myRadio" startes.
myRadio.setChannel(115); //Kanalen bliver sat til 115.
myRadio.setPALevel(RF24_PA_MAX); //Strømniveauet for modulet bliver sat til MAX. (Dette gøres kun, da der bliver brugt en solid strømkilde.)
myRadio.setDataRate(RF24_250KBPS); //Båndbredden bliver sat til 250 KBPS, da der ikke skal bruges mere end det, for at sende de 3 typer data.
myRadio.openReadingPipe(1, addresses[0]); //Der startes et "læse rør" med adressen, som blev sat til 0 tidligere.
myRadio.startListening(); //Modulet bliver sat til at lytte efter data.
}

void loop()
{

if (myRadio.available()) //Gør følgende, hvis der er data til rådighed.
{
while (myRadio.available()) //Gør følgende, så længe der er data til rådighed.
{
myRadio.read( &data, sizeof(data) ); //Læs data der er til rådighed og gem den i strukturen data.
}
Serial.print("\nPackage:"); //Et linjeskift efterfulgt af "Package:" bliver skrevet til den serielle monitor.
Serial.println(data.id); //Id i pakken data bliver skrevet til den serielle monitor.
Serial.println(data.temperature); //Den fiktive temperatur bliver skrevet til den serielle monitor.
Serial.println(data.text); //Teksten bliver skrevet til den serielle monitor.
}
}
</source>

Det er klart anbefalet at uploade koden til sender modulet fra en computer og koden til modtager modulet fra en anden, da man på den måde nemmere kan overskue den serielle monitor fra begge moduler.

===Forbedring af rækkevidden===
[[Fil:Nrf24l01-socket-8-pin.jpg|thumb|right|250px|NRF24L01 socket]]
Der kan gøres en række ting, for at forbedre rækkenvidden af NRF24L01 modulet:
* Den mest mærkbare ting, er at bruge en pålidelig 3.3V strømforsyning. Dette skyldes, at modulet bruger forholdsvist meget strøm i de meget korte øjeblikke, hvor den den sender data, selvom den alt i alt har et meget lavt strømforbrug. Arduinoen er nemlig kun i stand til at give 50 mA ved 3.3V. En løsning kan være, at bruge en anden strømforsyning eller bruge en bedre 3.3V regulator, til formindske arduinoens 5V, hvilket kan give rigeligt med strøm. Dette kan gøres, ved at bruge en såkaldt "NRF24L01 socket". Med dette modul er det muligt at bruge arduinoens 5V, mens det derudover også er nemmere at koble modulet til.
* En anden ting, der kan være med til at lave en mærkbar forskel, er at sætte en kondensator fra GND til VCC, så modulet kan suge lidt ekstra strøm, i de korte øjeblikke den har brug for det. Dette kan enten gøres på et breadboard, på en printplade, eller bare ved at lodde den direkte på modulet (Vær opmærksom på polaritet). Det er anbefalet at bruge en kondensator på mellem 3.3 og 10 µF. Nogle brugere har dog også haft meget god succes, med en kombination af en 10µF i parallel forbindelse med en 0.1µF kondensator.
* For at få så lang rækkevidde, som overhovedet muligt, er det en god idé, at sætte modulets strømniveau til det maksimale. Dette er dog kun, hvis den har mulighed for at benytte sig af så meget strøm, som den har brug for. Indtil man har en solid forbindelse, mellem to moduler, med en kort afstand imellem dem, er det en god idé at sætte strømniveauet til det minimale, og så derefter sætte det op. For at indstille strømniveuet, skal man skrive en af følgende fire kommandoer ind i setup:
<source lang="C">
radio.setPALevel(RF24_PA_MIN); //Sæt strømniveauet for modulet til det minimale
radio.setPALevel(RF24_PA_LOW); //Sæt strømniveauet for modulet til lav
radio.setPALevel(RF24_PA_HIGH); //Sæt strømniveauet for modulet til høj
radio.setPALevel(RF24_PA_MAX); //Sæt strømniveauet for modulet til det maksimale
</source>
* Hvis man ikke har brug for, at benytte sig af de fulde 2 Mbps, som modulet kan levere, kan man opnå en smule bedre rækkevidde, ved at begrænse hastigheden, hvorved dataen bliver sendt. Dette skal også indsættes i setup:
<source lang="C">
radio.setDataRate(RF24_250KBPS); //Sæt data hastigheden til 250 Kbps, for at opnå minimal rækkevidde.
radio.setDataRate(RF24_1MBPS); //Sæt data hastigheden til 1 Mbps, for at opnå middel hastighed og rækkevidde.
radio.setDataRate(RF24_2MBPS); //Sæt data hastigheden til 2 Mbps, for at opnå maksimal hastighed.
</source>
* Modulet er i stand til at bruge en frekvens på mellem 2.4 GHz og 2.525 GHz. Dette betyder, at man kan undgå den frekvens, som mange Wifi-netværk og Bluetooth apparater benytter sig af, nemlig ~ 2.4GHz. Modulet har 125 mulige kanaler, med 1 MHz mellemrum imellem dem. De 25 højeste kanaler, er anbefalet at bruge. Hvis man er i tvivl om, hvilken kanal der er bedst at bruge, kan man benytte sig af "scanner" eksemplet, som kigger efter interferens på de forskellige kanaler. For at benytte en kanal, skal følgende kommando bruges i setup:
<source lang="C">
radio.setChannel(CHANNEL_NUMBER); //Indsæt den valgte kanal fra 0 til 124 på pladsen CHANNEL_NUMBER.
</source>
Scanner eksemplet i Tmrh20's bibliotek virker ved at se efter, hvilke kanaler der bliver brugt meget, altså hvilke kanaler man vil opleve meget interferens på, hvis man benytter dem. Det kan godt være lidt forvirrende at finde ud af, hvad det, som programmet skriver i den serielle moniter skal betyde, men når man først forstår opsætningen er det meget nemt at finde ud af. Det skal ses som en tabel, hvor der er en masse lodrette rækker. De to første linjer er kanalen skrevet lodret i hex, så hvis der f.eks. står 3a, vises interferensen for kanal 58 lodret ned (da dette er det decimale tal for 33 i hex, da hex er et 16 base talsystem). De forskellige tal, der vises er hvor meget interferens der er på kanalen i hex. Så jo nærmere 0, jo bedre.
Nedenfor ses et eksempel på et serielt output for scanner programmet:
<pre>
RF24/examples/scanner/
000000000000000011111111111111112222222222222222333333333333333344444444444444445555555555555555666666666666666677777777777777
0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcd
011111000000122112311010122211233101123222001110000000010000132576445000000221111000000000000000000000000000000000000000000000
001000120010210025320122211120220100000000012111000000024553366456444000001000112000000000000000000000000000000000000000000000
001000000012211000101010112211111222322000011111111000036532354653000000001110112000000000000000000000000000000000000000000000
121100000121111100001111221000132121011000000002210000034321120220000000002221001100000000000000000000000000000000000000000000
000011110001221111111110113331011111200011001320000000034343653562554020000001310000000000000000000000000000000000000000000000
010111102111000121000002442211100112214422210100000000100003476a97465400000000121000000000000000000000000000000000000000000000
000000002413420001001001100011211101212433101010000001044565775677634010000000101000000000000000000000000000000000000000000000
001321021211111100111110122201001000000111100010011000055445763432010000000011010100000000000000000000000000000000000000000000
000100022211200110010000002032323310013211000001211000042200330112000010000011110100000000000000000000000000000000000000000000
000100011121012122011000134530001220000233100000110000000000120234345001000012223100000000000000000000000000000000000000000000
001000012121012332211120011112221111121222211110221000000023665876675010000000011000000000000000000000000000000000000000000000
014320001332113210010100131144110011121000000001000000155555564668432100000021122100000000000000000000000000000000000000000000
010211022320101122232110212101111000110001101111000001025444751332100110001121100000000000000000000000000000000000000000000000
</pre>
Som det kan ses, er kanalen 52 i hex (82 i decimal) og opefter ikke i brug. Disse ville derfor være optilmale til at bruge. Der er også nogle enkelte huller ind imellem som f.eks. kanal 33 i hex (51 i decimal).

==Referencer==
<references/>

{{Arduino-Modul-Oversigt}}

[[Kategori:Arduino Moduler]]

Printfremstilling

2025-12-27T16:55:41Z

Bar: /* Video med forklaringer */

==Kort huskeliste==
# Belys 2:00 - 3:00 (husk at tekst skal ende med at være læselig)
# Fremkald i 0,4M NaOH
# Skyl, aftør og bor 2mm hul
# Æts i Natriumpersulfat til banerne står frit
# Skyl og aftør
# Belys 2:00 - 3:00
# Fremkald i 0,4M NaOH
# Bor huller efter komponentbenene 0,8mm, 1,0mm, 1,3mm

==Generelt om printfremstilling==

Et print er en række lederbaner på et isolerende materiale. Tit bruger man den engelske betegnelse PCB (Print Circuit Board). Print kan til simplere formål fremstilles ved hjælp af en fotografisk proces, med efterfølgende ætsning.

Det rå print er en glasfiber-base med et kobberlag på den ene side (begge sider, hvis det skal være til dobbeltsidet). På dette kobberlag er der et lysfølsomt lag, der er specielt følsom over for ultraviolet lys. Dette lag er beskyttet af et lag papir, der ikke kan trænge lys igennem (heller ikke ultraviolet).

Mønsteret der skal overføres til printet skal være på en positiv film, altså en film der kan lyses igennem med et sort mønster hvor der skal være printbaner.

For at fremstille layoutet skal det printes på en passende film. Layoutet kan typisk fremstilles i [[:kategori:Eagle|Eagle]], hvor man starter i sit [[Schematics|Schematic]], hvor man skal vælge det fysiske komponenter der skal placeres på printet. Når man har tegnet hele diagrammet, så skal man placere komponenter og baner i [[Layout|PCB-Layout]], der også er en del af Eagle.

Fremkaldelsen af printet har den virkning at de dele der er blevet belyst, kan fjernes ved hjælp af natriumhydroxyd. Det der så er tilbage skal dække for kobberet, så det kun er de steder hvor der ikke skal være baner, at der ætses.

Ætsebadet er en opløsning af Natriumpersulfat (finætsekrystal), der arbejder ved hjælp af bobler. Den ætsende virkning kommer ved at persulfat-ionerne er så kraftigt oxiderende, at de er i stand til at trække det metalliske kobber ud i væsken, hvilket kan ses ved at væsken, der i starten er farveløs, får en klar blå farve.

==Om kemikalier.==
Ved arbejde med kemikalier bør man undgå hud- og øjenkontakt. Det anbefales at anvende gummihandsker og straks søge læge, hvis kemikalierne kommer i øjnene.

Kemikalier skal opbevares utilgængeligt for børn.

Beholdere med kemikalier skal mærkes med hvad de indeholder, og man skal orientere sig omkring de forskellige kemikaliers egenskaber (der hænger beskrivelser i ætse rummet).

==Belysning af Printet.==
Printet klippes til så det passer efter filmen, beregn ca. 0,5 mm ekstra, da de yderste kanter kan få beskadiet det lysfølsomme lag, ved klipning af printet.

Filmen placeres på glaspladen i lyskassen, så teksterne er spejlvendt, og printet med den lysfølsomme side ned mod filmen (husk at pille papiret af), og placeres så banerne ikke berører kanterne af printet. Låget til lyskassen lukkes og spændes til, så der er optimal kontakt mellem film og print.

Belys printet i ca. 3 minutter (300 på timeren). Timeren starter ved tryk på instillingsknappen. Hvis printet er ved at være gammelt, så kan det reddes ved at forøge belysningstiden til 4 minutter.

==Fremkaldelse af printet.==
Printet fremkaldes i en 0,4 M opløsning af NaOH (12g pr. liter). Opløsningen er basisk og ætsende.

Fremkald printet i en fotobakke, ved at hælde ca. 200ml i bakken og bevæge væsken, så man kan se hvordan fremkaldeprocessen skrider frem. Anvend evt. en fin pensel til at fremskynde processen, men pas på ikke at ridse den lysfølsomme film.

Fremkaldelsen tager ca. ½ minut.

Skyl printet godt under vandhanen (pas på ikke at ridse printet).

Brugt fremkalder hældes i basisk affald.

==Ætsning af printet.==
Printet ætses i Natriumpersulfat (koncentration 200 g/liter). Natriumpersulfat er ætsende og affarver tøjet - det ses normalt ikke før tøjet er vasket.

[http://www.cypax.com/pdf/natriumpersulfat_rev.pdf Kemikalie-beskrivelse af Natriumpersulfat].

Der bores et 2mm hul et sted i printet hvor det ikke betyder noget.

Printet placeres midt i printholderen så man kan se kobbersiden. Anvend plast-isoleret ledning til at placere printet fornuftigt i ætsekarret – ætsetiden fremskyndes ved at boblerne passerer hen over printet.

Hvis ætsetiden kommer over 30 minutter i varm tilstand er væskens ætseevne ved at være brugt op og skal udskiftes. Brugt ætsevæske hældes i surt affald.

==Efterbehandling af printet.==
Resterne af det lysfølsomme lag fjernes ved at belyse igen (3 minutter uden film), og fremkalde det lysfølsomme lag af kobberbanerne.

Printet bores med de størrelser huller der passer til komponentbenene (0,8mm 1,0mm og 1,3mm).

==RYD FOR H . . . . . . OP==
Fremkalderbakken tømmes og fremkalderen i kommes basisk affald. Fremkalderbakken skylles grundigt .

Ætsemaskinen tildækkes så væsken ikke fordamper, og der slukkes for strømmen.

Alt stilles på plads, og bordet tørres af.

==Video med forklaringer==

Printfremstilling laves på professionel vis, og hovedparten produceres i Kina - her er lige en film der viser hele processen, når man skal lave dobbeltsidet print med loddemaske og silketryk. 
{{#ev:youtube|_GVk_hEMjzs}} 
[https://www.youtube.com/watch?v=_GVk_hEMjzs Direkte link]

Jeg har venligst fået lov til at inkludere disse to videoer fra John Ellekrogh der arbejder på Viby HTX.

Det er ikke alle materialer og tider der passer præcist, men det er en god omtale af teknikken.

Teknikken omkring kring det at få fremstillet filmen til et printudlæg 
{{#ev:youtube|vZEVSyKoho8}} 
[https://www.youtube.com/watch?v=vZEVSyKoho8 Direkte link]

Teknikken om at få belyst, fremkaldt og ætset sit print, så det er klar til boring 
{{#ev:youtube|Bx6s034CoqM}} 
[http://youtu.be/Bx6s034CoqM Direkte link]

Noget af processen igen, med lidt andre kommentarer og tider - helt frem til at printet er loddet 
{{#ev:youtube|EDJmKeOch9o}} 
[https://www.youtube.com/watch?v=EDJmKeOch9o Direkte link]

{{Elektronik-Montage}}

[[Kategori:Elektronik_Montage]]
[[Kategori:værkstedet]]
[[Kategori:Hardware Udviklingsteknikker]]

Printfremstilling

2025-12-27T16:52:53Z

Bar: /* Video med forklaringer */

==Kort huskeliste==
# Belys 2:00 - 3:00 (husk at tekst skal ende med at være læselig)
# Fremkald i 0,4M NaOH
# Skyl, aftør og bor 2mm hul
# Æts i Natriumpersulfat til banerne står frit
# Skyl og aftør
# Belys 2:00 - 3:00
# Fremkald i 0,4M NaOH
# Bor huller efter komponentbenene 0,8mm, 1,0mm, 1,3mm

==Generelt om printfremstilling==

Et print er en række lederbaner på et isolerende materiale. Tit bruger man den engelske betegnelse PCB (Print Circuit Board). Print kan til simplere formål fremstilles ved hjælp af en fotografisk proces, med efterfølgende ætsning.

Det rå print er en glasfiber-base med et kobberlag på den ene side (begge sider, hvis det skal være til dobbeltsidet). På dette kobberlag er der et lysfølsomt lag, der er specielt følsom over for ultraviolet lys. Dette lag er beskyttet af et lag papir, der ikke kan trænge lys igennem (heller ikke ultraviolet).

Mønsteret der skal overføres til printet skal være på en positiv film, altså en film der kan lyses igennem med et sort mønster hvor der skal være printbaner.

For at fremstille layoutet skal det printes på en passende film. Layoutet kan typisk fremstilles i [[:kategori:Eagle|Eagle]], hvor man starter i sit [[Schematics|Schematic]], hvor man skal vælge det fysiske komponenter der skal placeres på printet. Når man har tegnet hele diagrammet, så skal man placere komponenter og baner i [[Layout|PCB-Layout]], der også er en del af Eagle.

Fremkaldelsen af printet har den virkning at de dele der er blevet belyst, kan fjernes ved hjælp af natriumhydroxyd. Det der så er tilbage skal dække for kobberet, så det kun er de steder hvor der ikke skal være baner, at der ætses.

Ætsebadet er en opløsning af Natriumpersulfat (finætsekrystal), der arbejder ved hjælp af bobler. Den ætsende virkning kommer ved at persulfat-ionerne er så kraftigt oxiderende, at de er i stand til at trække det metalliske kobber ud i væsken, hvilket kan ses ved at væsken, der i starten er farveløs, får en klar blå farve.

==Om kemikalier.==
Ved arbejde med kemikalier bør man undgå hud- og øjenkontakt. Det anbefales at anvende gummihandsker og straks søge læge, hvis kemikalierne kommer i øjnene.

Kemikalier skal opbevares utilgængeligt for børn.

Beholdere med kemikalier skal mærkes med hvad de indeholder, og man skal orientere sig omkring de forskellige kemikaliers egenskaber (der hænger beskrivelser i ætse rummet).

==Belysning af Printet.==
Printet klippes til så det passer efter filmen, beregn ca. 0,5 mm ekstra, da de yderste kanter kan få beskadiet det lysfølsomme lag, ved klipning af printet.

Filmen placeres på glaspladen i lyskassen, så teksterne er spejlvendt, og printet med den lysfølsomme side ned mod filmen (husk at pille papiret af), og placeres så banerne ikke berører kanterne af printet. Låget til lyskassen lukkes og spændes til, så der er optimal kontakt mellem film og print.

Belys printet i ca. 3 minutter (300 på timeren). Timeren starter ved tryk på instillingsknappen. Hvis printet er ved at være gammelt, så kan det reddes ved at forøge belysningstiden til 4 minutter.

==Fremkaldelse af printet.==
Printet fremkaldes i en 0,4 M opløsning af NaOH (12g pr. liter). Opløsningen er basisk og ætsende.

Fremkald printet i en fotobakke, ved at hælde ca. 200ml i bakken og bevæge væsken, så man kan se hvordan fremkaldeprocessen skrider frem. Anvend evt. en fin pensel til at fremskynde processen, men pas på ikke at ridse den lysfølsomme film.

Fremkaldelsen tager ca. ½ minut.

Skyl printet godt under vandhanen (pas på ikke at ridse printet).

Brugt fremkalder hældes i basisk affald.

==Ætsning af printet.==
Printet ætses i Natriumpersulfat (koncentration 200 g/liter). Natriumpersulfat er ætsende og affarver tøjet - det ses normalt ikke før tøjet er vasket.

[http://www.cypax.com/pdf/natriumpersulfat_rev.pdf Kemikalie-beskrivelse af Natriumpersulfat].

Der bores et 2mm hul et sted i printet hvor det ikke betyder noget.

Printet placeres midt i printholderen så man kan se kobbersiden. Anvend plast-isoleret ledning til at placere printet fornuftigt i ætsekarret – ætsetiden fremskyndes ved at boblerne passerer hen over printet.

Hvis ætsetiden kommer over 30 minutter i varm tilstand er væskens ætseevne ved at være brugt op og skal udskiftes. Brugt ætsevæske hældes i surt affald.

==Efterbehandling af printet.==
Resterne af det lysfølsomme lag fjernes ved at belyse igen (3 minutter uden film), og fremkalde det lysfølsomme lag af kobberbanerne.

Printet bores med de størrelser huller der passer til komponentbenene (0,8mm 1,0mm og 1,3mm).

==RYD FOR H . . . . . . OP==
Fremkalderbakken tømmes og fremkalderen i kommes basisk affald. Fremkalderbakken skylles grundigt .

Ætsemaskinen tildækkes så væsken ikke fordamper, og der slukkes for strømmen.

Alt stilles på plads, og bordet tørres af.

==Video med forklaringer==

Printfremstilling laves på professionel vis, og hovedparten produceres i Kina - her er lige en film der viser hele processen, når man skal lave dobbeltsidet print med loddemaske og silketryk. 
{{#ev:youtube|_GVk_hEMjzs}} 
[https://www.youtube.com/watch?v=_GVk_hEMjzs Direkte link]

Jeg har venligst fået lov til at inkludere disse to videoer fra John Ellekrogh der arbejder på Viby HTX.

Det er ikke alle materialer og tider der passer præcist, men det er en god omtale af teknikken.

Teknikken omkring kring det at få fremstillet filmen til et printudlæg 
{{#ev:<youtube>|vZEVSyKoho8}} 
[https://www.youtube.com/watch?v=vZEVSyKoho8 Direkte link]

Teknikken om at få belyst, fremkaldt og ætset sit print, så det er klar til boring 
{{#ev:youtube|Bx6s034CoqM}} 
[http://youtu.be/Bx6s034CoqM Direkte link]

Noget af processen igen, med lidt andre kommentarer og tider - helt frem til at printet er loddet 
{{#ev:youtube|EDJmKeOch9o}} 
[https://www.youtube.com/watch?v=EDJmKeOch9o Direkte link]

{{Elektronik-Montage}}

[[Kategori:Elektronik_Montage]]
[[Kategori:værkstedet]]
[[Kategori:Hardware Udviklingsteknikker]]

Breadboard

2025-12-26T10:51:50Z

Bar: /* Opbygning af opstillinger på Breadboard */

Et Breadboard (også kaldet fumlebræt) er designet til at opbygge simple kredsløb uden at lodde.

Det oprindelige udtryk stammer fra den tidlige elektronik-tid, hvor man lavede simple kredsløb ved at slå søm i et skærebræt, og lodde komponenterne på sømhovederne.

Det nuværende breadboard er noget simplere at anvende, da man blot kan stikke komponentbenene ned i hullerne, hvor der så er et net af forbindelser.

Der findes forskellige størrelser, men et meget anvendt format et følgende:

[[Fil:Breadboard_Udseende.png|400px|Udseende af typisk Breadboard med 2 x 30 rækker]] 
''Udseende af typisk Breadboard med 2 x 30 rækker''

==Forbindelserne i et Breadboard==
Nede i Breadboardet får komponenterne forbindelse med nogle metalskinner, der forbinder hullerne i en bestemt struktur.

Der er typisk en eller to baner på hver side, som har forbindelse hele vejen hen gennem breadboardet. De er ofte markeret med + og -.

Inde omkring midten ligger der forbindelser den modsatte vej, som går ud fra midten af breadboardet.

Dette er illustreret herunder.

[[Fil:Breadboard_Forbindelser.png|400px|Forbindelserne i et typisk Breadboard markeret med sorte streger]] 
''Forbindelserne i et typisk Breadboard markeret med sorte streger''

En anden type breadboard er fotograferet herunder.

[[Fil:Breadboard_Foto.png|400px|Foto af en anden type Breadboard]] 
''Foto af en anden type Breadboard''

For at vise hvordan forbindelserne er lavet, er der herunder vist et billede fra undersiden af breadboardet, hvor beskyttelsen er delvist pillet af.

[[Fil:Breadboard_Bagside.png|400px|Det ovenstående Breadboard fotograferet fra bunden, med beskyttelsen fjernet]] 
''Det ovenstående Breadboard fotograferet fra bunden, med beskyttelsen fjernet''

==Opbygning af opstillinger på Breadboard==

Layoutet af Breadboardet er lavet ud fra at IC'er kan monteres i midten af breadboardet, så man får mange muligheder for forbindelser

[[Fil:Breadboard_IC.png|150px|Placeringen af en IC i en del af et breadboard]] 
''Placeringen af en IC i en del af et breadboard''

Herunder er vist hvordan man kan koble en opstilling op på et breadboard. Opstillingen er tegnet i [https://www.tinkercad.com/ www.TinkerCad.com], der i skrivende stund er et gratis værktøj fra Autodesk. Der ligger flere muligheder her, men dette kan tegnes inde under Circuits.

[[Fil:Breadboard_Opstilling.png|800px|En opstilling på breadboard koblet sammen med en Arduino UNO]] 
''En opstilling på breadboard koblet sammen med en Arduino UNO''

Kredsløbet der er bygget på breadboard er en simpel transistor, der driver en lysdiode, som vist på diagrammet herunder.

[[Fil:Breadboard_Diagram.png|800px|Diagram over ovenstående opstilling på breadboard]] 
''Diagram over ovenstående opstilling på breadboard''

==Komponenter der typisk anvendes sammen med Breadboard==

Breadboards kan naturligvis anvendes generelt, men de bliver meget brugt sammen med [[Arduino_Hardware#Breadboard|Arduino Hardware]], hvor der også omtales nogle af de andre ting, det er en fordel at have for at komme i gang.

{{Elektronik-Montage}}

[[Kategori:Elektronik_Montage]]

Breadboard

2025-12-26T10:51:31Z

Bar: /* Opbygning af opstillinger på Breadboard */

Et Breadboard (også kaldet fumlebræt) er designet til at opbygge simple kredsløb uden at lodde.

Det oprindelige udtryk stammer fra den tidlige elektronik-tid, hvor man lavede simple kredsløb ved at slå søm i et skærebræt, og lodde komponenterne på sømhovederne.

Det nuværende breadboard er noget simplere at anvende, da man blot kan stikke komponentbenene ned i hullerne, hvor der så er et net af forbindelser.

Der findes forskellige størrelser, men et meget anvendt format et følgende:

[[Fil:Breadboard_Udseende.png|400px|Udseende af typisk Breadboard med 2 x 30 rækker]] 
''Udseende af typisk Breadboard med 2 x 30 rækker''

==Forbindelserne i et Breadboard==
Nede i Breadboardet får komponenterne forbindelse med nogle metalskinner, der forbinder hullerne i en bestemt struktur.

Der er typisk en eller to baner på hver side, som har forbindelse hele vejen hen gennem breadboardet. De er ofte markeret med + og -.

Inde omkring midten ligger der forbindelser den modsatte vej, som går ud fra midten af breadboardet.

Dette er illustreret herunder.

[[Fil:Breadboard_Forbindelser.png|400px|Forbindelserne i et typisk Breadboard markeret med sorte streger]] 
''Forbindelserne i et typisk Breadboard markeret med sorte streger''

En anden type breadboard er fotograferet herunder.

[[Fil:Breadboard_Foto.png|400px|Foto af en anden type Breadboard]] 
''Foto af en anden type Breadboard''

For at vise hvordan forbindelserne er lavet, er der herunder vist et billede fra undersiden af breadboardet, hvor beskyttelsen er delvist pillet af.

[[Fil:Breadboard_Bagside.png|400px|Det ovenstående Breadboard fotograferet fra bunden, med beskyttelsen fjernet]] 
''Det ovenstående Breadboard fotograferet fra bunden, med beskyttelsen fjernet''

==Opbygning af opstillinger på Breadboard==

Layoutet af Breadboardet er lavet ud fra at IC'er kan monteres i midten af breadboardet, så man får mange muligheder for forbindelser

[[Fil:Breadboard_IC.png|150px|Placeringen af en IC i en del af et breadboard]] 
''Placeringen af en IC i en del af et breadboard''

Herunder er vist hvordan man kan koble en opstilling op på et breadboard. Opstillingen er tegnet i [https://www.tinkercad.com/ www.TinkerCad.com], der i skrivende stund er et gratis værktøj fra Autodesk. Der ligger flere muligheder her, men dette kan tegnes inde under Circuits.

[[Fil:Breadboard_Opstilling.png|800px|En opstilling på breadboard koblet sammen med en Arduino UNO]] 
''En opstilling på breadboard koblet sammen med en Arduino UNO''

Kredsløbet der er bygget på breadboard er en simpel transistor, der driver en lysdiode, som vist på diagrammet herunder.

[[Fil:Breadboard_Diagram.png|Diagram over ovenstående opstilling på breadboard]] 
''Diagram over ovenstående opstilling på breadboard''

==Komponenter der typisk anvendes sammen med Breadboard==

Breadboards kan naturligvis anvendes generelt, men de bliver meget brugt sammen med [[Arduino_Hardware#Breadboard|Arduino Hardware]], hvor der også omtales nogle af de andre ting, det er en fordel at have for at komme i gang.

{{Elektronik-Montage}}

[[Kategori:Elektronik_Montage]]

Breadboard

2025-12-26T10:34:19Z

Bar: /* Opbygning af opstillinger på Breadboard */

Breadboard

2025-12-26T10:25:46Z

Bar: /* Opbygning af opstillinger på Breadboard */

Et Breadboard (også kaldet fumlebræt) er designet til at opbygge simple kredsløb uden at lodde.

Det oprindelige udtryk stammer fra den tidlige elektronik-tid, hvor man lavede simple kredsløb ved at slå søm i et skærebræt, og lodde komponenterne på sømhovederne.

Det nuværende breadboard er noget simplere at anvende, da man blot kan stikke komponentbenene ned i hullerne, hvor der så er et net af forbindelser.

Der findes forskellige størrelser, men et meget anvendt format et følgende:

[[Fil:Breadboard_Udseende.png|400px|Udseende af typisk Breadboard med 2 x 30 rækker]] 
''Udseende af typisk Breadboard med 2 x 30 rækker''

==Forbindelserne i et Breadboard==
Nede i Breadboardet får komponenterne forbindelse med nogle metalskinner, der forbinder hullerne i en bestemt struktur.

Der er typisk en eller to baner på hver side, som har forbindelse hele vejen hen gennem breadboardet. De er ofte markeret med + og -.

Inde omkring midten ligger der forbindelser den modsatte vej, som går ud fra midten af breadboardet.

Dette er illustreret herunder.

[[Fil:Breadboard_Forbindelser.png|400px|Forbindelserne i et typisk Breadboard markeret med sorte streger]] 
''Forbindelserne i et typisk Breadboard markeret med sorte streger''

En anden type breadboard er fotograferet herunder.

[[Fil:Breadboard_Foto.png|400px|Foto af en anden type Breadboard]] 
''Foto af en anden type Breadboard''

For at vise hvordan forbindelserne er lavet, er der herunder vist et billede fra undersiden af breadboardet, hvor beskyttelsen er delvist pillet af.

[[Fil:Breadboard_Bagside.png|400px|Det ovenstående Breadboard fotograferet fra bunden, med beskyttelsen fjernet]] 
''Det ovenstående Breadboard fotograferet fra bunden, med beskyttelsen fjernet''

==Opbygning af opstillinger på Breadboard==

Layoutet af Breadboardet er lavet ud fra at IC'er kan monteres i midten af breadboardet, så man får mange muligheder for forbindelser

[[Fil:Breadboard_IC.png|150px|Placeringen af en IC i en del af et breadboard]] 
''Placeringen af en IC i en del af et breadboard''

Herunder er vist hvordan man kan koble en opstilling op på et breadboard. Opstillingen er tegnet i [https://www.tinkercad.com/ www.TinkerCad.com], der i skrivende stund er et gratis værktøj fra Autodesk. Der ligger flere muligheder her, men dette kan tegnes inde under Circuits.

[[Fil:Breadboard_Opstilling.png|800px|En opstilling på breadboard koblet sammen med en Arduino UNO]] 
''En opstilling på breadboard koblet sammen med en Arduino UNO''

Kredsløbet der er bygget på breadboard er en simpel transistor, der driver en lysdiode, som vist på diagrammet herunder.

[[Fil:Breadboard_Diagram.png|Diagram over ovenstående opstilling på breadboard]] 
''Diagram over ovenstående opstilling på breadboard''

==Komponenter der typisk anvendes sammen med Breadboard==

Breadboards kan naturligvis anvendes generelt, men de bliver meget brugt sammen med [[Arduino_Hardware#Breadboard|Arduino Hardware]], hvor der også omtales nogle af de andre ting, det er en fordel at have for at komme i gang.

{{Elektronik-Montage}}

[[Kategori:Elektronik_Montage]]

Breadboard

2025-12-26T10:22:55Z

Bar: /* Opbygning af opstillinger på Breadboard */

Breadboard

2025-12-26T10:22:34Z

Bar: /* Opbygning af opstillinger på Breadboard */

Et Breadboard (også kaldet fumlebræt) er designet til at opbygge simple kredsløb uden at lodde.

Det oprindelige udtryk stammer fra den tidlige elektronik-tid, hvor man lavede simple kredsløb ved at slå søm i et skærebræt, og lodde komponenterne på sømhovederne.

Det nuværende breadboard er noget simplere at anvende, da man blot kan stikke komponentbenene ned i hullerne, hvor der så er et net af forbindelser.

Der findes forskellige størrelser, men et meget anvendt format et følgende:

[[Fil:Breadboard_Udseende.png|400px|Udseende af typisk Breadboard med 2 x 30 rækker]] 
''Udseende af typisk Breadboard med 2 x 30 rækker''

==Forbindelserne i et Breadboard==
Nede i Breadboardet får komponenterne forbindelse med nogle metalskinner, der forbinder hullerne i en bestemt struktur.

Der er typisk en eller to baner på hver side, som har forbindelse hele vejen hen gennem breadboardet. De er ofte markeret med + og -.

Inde omkring midten ligger der forbindelser den modsatte vej, som går ud fra midten af breadboardet.

Dette er illustreret herunder.

[[Fil:Breadboard_Forbindelser.png|400px|Forbindelserne i et typisk Breadboard markeret med sorte streger]] 
''Forbindelserne i et typisk Breadboard markeret med sorte streger''

En anden type breadboard er fotograferet herunder.

[[Fil:Breadboard_Foto.png|400px|Foto af en anden type Breadboard]] 
''Foto af en anden type Breadboard''

For at vise hvordan forbindelserne er lavet, er der herunder vist et billede fra undersiden af breadboardet, hvor beskyttelsen er delvist pillet af.

[[Fil:Breadboard_Bagside.png|400px|Det ovenstående Breadboard fotograferet fra bunden, med beskyttelsen fjernet]] 
''Det ovenstående Breadboard fotograferet fra bunden, med beskyttelsen fjernet''

==Opbygning af opstillinger på Breadboard==

Layoutet af Breadboardet er lavet ud fra at IC'er kan monteres i midten af breadboardet, så man får mange muligheder for forbindelser

[[Fil:Breadboard_IC.png|150px|Placeringen af en IC i en del af et breadboard]] 
''Placeringen af en IC i en del af et breadboard''

Herunder er vist hvordan man kan koble en opstilling op på et breadboard. Opstillingen er tegnet i [https://www.tinkercad.com/ www.TinkerCad.com], der i skrivende stund er et gratis værktøj fra Autodesk. Der ligger flere muligheder her, men dette kan tegnes inde under Circuits.

[[Fil:Breadboard_Opstilling.png|800px|En opstilling på breadboard koblet sammen med en Arduino UNO]] 
''En opstilling på breadboard koblet sammen med en Arduino UNO''

Kredsløbet der er bygget på breadboard er en simpel transistor, der driver en lysdiode, som vist på diagrammet herunder.

[[Fil:Breadboard_Diagram.png|Diagram over ovenstående opstilling på breadboard]] 
''Diagram over ovenstående opstilling på breadboard''

==Komponenter der typisk anvendes sammen med Breadboard==

Breadboards kan naturligvis anvendes generelt, men de bliver meget brugt sammen med [[Arduino_Hardware#Breadboard|Arduino Hardware]], hvor der også omtales nogle af de andre ting, det er en fordel at have for at komme i gang.

{{Elektronik-Montage}}

[[Kategori:Elektronik_Montage]]

Arduinos Biblioteker

2024-09-03T07:00:24Z

Bar: /* Steder at finde biblioteker */

Denne beskrivelse er lavet ud fra Arduinos beskrivelse af biblioteker<ref name="libraries">[https://www.arduino.cc/en/Hacking/Libraries Arduino Libraries - Beskrivelse af hvordan man arbejder generelt med biblioteker]</ref> på deres egen side.

==Standard biblioteker==
Det er en fordel IKKE at pille ved standard bibliotekerne.

Som standard ligger der en del biblioteker installeret sammen med Arduinos PC program som standard indstillinger.

[[Fil:arduino_library_structure.png|thumb|right|Biblioteks-strukturen for Arduino]]
==Tilføjelse af biblioteker==
Man kan tilføje biblioteker (testet i version 1.6.4) ved at gå ind i "Sketch - Include Library - Manage Libraries...", hvor man kan finde en del biblioteker, som downloades fra nettet, eller hvis man har en zip-fil med et bibliotek, så kan man gå ind i "Sketch - Include Library - Add .ZIP Library..." - i begge tilfælde placeres biblioteket inde i den korrekte struktur og kan anvendes direkte.

Hvert bibliotek ligger i sin egen mappe, og navnet på biblioteket skal være det samme som den mappe det ligger inde i, og den mappestruktur der er inde i biblioteket angiver.

Som det er angivet på figuren her til højre, så ligger de biblioteker man selv ønsker at tilføje inde i '''Dokumenter\Arduino\libraries\''', hvor der i dette eksempel kun er tilføjet et Keypad bibliotek.

Et bibliotek vil normalt være skrevet i C eller C++ og vil kunne lette tilgangen til et stykke hardware som et display eller et tastatur.

===Anvendelse af biblioteker===
Det letteste måde at anvende et bibliotek på er at man i IDE'et går ind i "Sketch" - "Library" og vælger det bibliotek man ønsker at tilføje. Dette vil give en linje som vist her:

#include <Keypad.h>

Til mange biblioteker er det ikke altid nok for at forstå hvordan man anvender bibilioteket, her vil de fleste biblioteker komme med et eller flere eksempler.

Har man lagt biblioteket rigtigt ind, så vil man kunne finde eksemplerne inde under "Fil" - "Eksempler" - "det relevante bibliotek".

===Uautorisert måde at lægge biblioteker ind på===
Hvis man har administratorrettigheder, så kan man tilføje biblioteker inde sammen med standard bibliotekerne. Denne metode anbefales ikke.

==Steder at finde biblioteker==
Der er mange biblioteker <ref>http://playground.arduino.cc/Main/LibraryList Liste over de forskellige biblioteker man kan hente fra Arduinos hjemmeside</ref> på Arduinos hjemmeside.

Et andet sted hvor der ligger rigtigt meget er på github.com<ref>[https://github.com/ site til samarbejde omkring software]</ref>. Det kan være svært at navigere i stedet for at finde frem til relevante biblioteker, men man kan tit google sig frem til gode resultater ved at tilføje "github arduino library" til sin søgning efter noget hardware man ikke har kunnet finde på Arduinos side

==At skrive sine biblioteker selv==
Man kan også selv skrive og udvikle biblioteker<ref name="writeLib">http://playground.arduino.cc/Code/Library Beskrivelse af hvordan biblioteker skal skrives</ref>, og hvis man syntes man har skrevet et godt bibliotek kan man også poste det f.x. i Arduinos forum<ref>[http://forum.arduino.cc/ Arduinos forum]</ref> så andre får glæde af arbejdet.

Hvis man ønsker at skrive et bibliotek, så er det en god ide at kende strukturen i hvordan man skriver et bibliotek, da man skal skrive C++ kode, og man skal regne syntaksen i class-definitionen ud, som i sin grundlæggende struktur bliver beskrevet på Arduinos side<ref name="writeLib"></ref>. Eksemplet her er dog meget simpelt, så hvis man vil ud i noget der er mere avanceret, så er det en god ide at kigge i andre lidt større eksempler, gerne fra Arduinos egen hjemmeside.

Som vist herunder, så indeholder et bibliotek flere elementer, og det kan gøres mere eller mindre avanceret. Her vises et eksempel på Keypad-biblioteket: 
[[fil:keypad_library.png|Oversigt over Keypad biblioteket]] ''Oversigt over Keypad biblioteket''

Der er en del ting der er værd at bemærke:
*keypad mappen ligger i mappen libraries
*De to filer keypad.cpp (C++ filen) og keypad.h (include-filen) skal hedde det samme som mappen
*keywords.txt indeholder de ord der skal syntaksfarves når man anvender biblioteket
*mappen examples indeholder som man kan se 7 forskellige eksempler på hvordan keypad kan bruges
*i dette eksempel er der mappen utility, som indeholder en class-fil der anvendes inde i keypad

Ens eget bibliotek behøves ikke være så omfattende, men som minimum et eksempel der viser bruget af biblioteket, og som er skrevet så man kan se strukturen i hvordan man anvender biblioteket.

===Ekstern hjælp til at skrive biblioteker===
På Arduinos hjemmeside er der skrevet forskellig hjælp til at oprette sine egne biblioteker.

Selve indholdet i biblioteket er forklaret på Library Tutorial<ref>[https://www.arduino.cc/en/Hacking/libraryTutorial Library Tutorial]</ref>. Forklaringen har ikke så meget fokus på strukturen i biblioteket, og man skal læse siden godt igennem, for at kunne se hvor de forskellige dele skal placeres i de forskellige filer.

For at få styr på hvordan koden fordeles i de forskellige filer kan det være lettest at kigge på et eksempel, hvor der på Arduino Libraries<ref name="libraries"></ref> er lavet et test eksempel nederst på siden, som illustrerer strukturen, men ikke har nogen egentlig funktion.

Hvis man vil dele sit bibliotek med andre er gitHub.com et godt sted. For at optræde fornuftigt på gitHub er det en god ide at sikre sig at biblioteket både fungerer ordentligt og er veldokumenteret - se hvordan forskellige andre gør det. Når man har et bibliotek som er værd at dele, så kan man få hjælp til at uploade ved gitHub<ref>[https://github.com/firstcontributions/first-contributions Beskrivelse af hvordan man lægger sit første bidrag op]</ref> eller en anden guide<ref>[https://akrabat.com/the-beginners-guide-to-contributing-to-a-github-project/ akrabat.com guide to gitHub]</ref>. Man kan også kigge på andre måder at dele softwaren på ud fra beskrivelsen på Arduinos playground<ref>[https://playground.arduino.cc/Code/Library/#Sharing Forskellige deling af biblioteker]</ref>.

==Referencer==
<references />

{{Arduino-Modul-Oversigt}}

[[Kategori:Arduino]]

Prog Shield LED Strip

2024-09-02T18:29:12Z

Bar:

[[fil:WS2812_LED-Strip.jpg|thumb|right|SW2812 LED Strip]]

WS2812 LED Strip er en række med RGB LED'er, der kan styres af en enkelt digital pin. Antallet af LED'er er begrænset af hvor meget strøm der kan leveres af Arduinoen.

Den viste strip har 18 LED'er og den den anvendte til eksemplet. Den er koblet op med en modstand (330-680 ohm), der fungerer som beskyttelse af både Arduino og LED-Strip ved fejltilslutning.
==Software==
Softwaren er baseret på et bibliotek lavet af Daniel Garcia<ref>[https://www.arduino.cc/reference/en/libraries/fastled/ LED-Strip library udviklet af Daniel Garcia] placeret ved GitHub</ref>, og kan downloades som en ZIP-fil fra [https://downloads.arduino.cc/libraries/github.com/FastLED/FastLED-3.7.4.zip Denne ZIP-fil]. Biblioteket downloades og installeres som beskrevet under [[Arduinos_Biblioteker#Tilføjelse_af_biblioteker|Arduinos biblioteker]].

===Anvendelsen af softwaren===
Som alle andre biblioteker skal der sættes de grundlæggende ting op for at kontakte biblioteket og definere fugtsensoren, med ben og type osv.
<SyntaxHighlight lang="c">
// Bibliotek, der kan styre forskellige typer LED-strips, her iblandt WS2812
#include <FastLED.h>

#define LED_STRIP1 2 // LED strip på pin 2
#define NUM_LEDS 18 // Antal LED på strip

CRGB leds1[NUM_LEDS]; // Array med farveangivelse til hver LED
</SyntaxHighlight>

Til programmet anvendes enkelte variabler til styring af tid og farver:

<SyntaxHighlight lang="C">
int delayval = 100; // timing delay in milliseconds

int i; // Tæller-variabel til at indeksere med
byte R = 0; // Mængde af Rød
byte G = 255; // Mængde af Grøn
byte B = 0; // Mængde af Blå
</SyntaxHighlight>

Inde i [[setup()]] skrives en velkomst og der skal sættes gang i objektet ved hjælp af begin-metoden som vist her:
<SyntaxHighlight lang="C">
void setup() {
Serial.begin(9600);
delay(200);
Serial.println("Demo af LED-Strip WS2812");
// Opsætning af type, benforbindelse og data
FastLED.addLeds<WS2812, LED_STRIP1, GRB>(leds1, NUM_LEDS);
}
</SyntaxHighlight>

I [[loop()]] genneløbes en forløkke med alle LED'er, hvor farven sættes og vises, og efter et delay slukkes det igen:
<SyntaxHighlight lang="C">
void loop() {
for (i = 0; i < NUM_LEDS; i++){ // Løb alle LED igennem
leds1[i] = CRGB(R, G, B); // Sæt farven på den aktuelle LED
FastLED.show(0); // Vis alle dioder - parameter 50 er intensitet for alle (0-255)
delay(200); // Vent 200 ms
leds1[i] = CRGB(0, 0, 0); // Sluk den aktuelle LED igen
}
}
</SyntaxHighlight>

Koden laver et løbelys hen ad LED-Strippen, der gentages i det uendelige.

===Anvendelse af millis() i softwaren===
Koden i det viste eksempel anvender [[delay()]], hvilket gør at koden er blokeret det meste af tiden. Hvis man vil uden om dette, så er løsningen at anvende [[millis()]], der måler tiden på en anden måde, ved at bruge indbygget tidsmåling i Arduinoen.

Koden laver en lidt anden funktion, men ser ud på følgende måde:
<SyntaxHighlight lang="C">
// Bibliotek, der kan styre forskellige typer LED-strips, her iblandt WS2812
#include <FastLED.h>

#define LED_STRIP1 2 // LED strip på pin 3
#define NUM_LEDS 18 // Antal LED på strip

CRGB leds1[NUM_LEDS]; // Array med farveangivelse til hver LED

int i = 0; // Tæller-variabel til at indeksere med
byte R = 255; // Mængde af Rød (0 - 255)
byte G = 255; // Mængde af Grøn (0 - 255)
byte B = 255; // Mængde af Blå (0 - 255)
unsigned long time = 0;
const int interval = 200;
unsigned long startTime = 0;
unsigned long endTime = 0;

void setup() { // Opsætning af type, benforbindelse og data
Serial.begin(9600);
FastLED.addLeds<WS2812, LED_STRIP1, GRB>(leds1, NUM_LEDS);
delay(200);
}

void loop() {
if ((millis() - time) > interval) { // Er det tid til næste handling
time = time + interval; // Sæt tiden frem til næste handling
i++; // Tæl frem til næste LED
if (i >= NUM_LEDS) { // Begræns tæller til antallet af LED
for (i = 0; i < NUM_LEDS; i++) {
leds1[i] = CRGB(0, 0, 0); // Sluk den sidste LED igen
}
i = 0;
}
leds1[i] = CRGB(R, G, B); // Sæt farven på den aktuelle LED
startTime = micros();
FastLED.show(50); // Vis alle dioder
endTime = micros();
if (i == 12) {
Serial.println(endTime - startTime);
}
}
}
</SyntaxHighlight>

Der er lavet et eksempel på kode med millis, hvor man med en knap kan stoppe og starte løbelyset på et hvilket som helst tidspunkt. Begge koder ligger i [[media:LED-Strip-kode.zip|Denne ZIP-fil]], og for at kunne anvende eksemplet med millis, så skal man have installeret ezButton biblioteket<ref>[https://www.arduino.cc/reference/en/libraries/ezbutton/ Arduinos omtale af] exButton</ref>. Dette kan hentes fra [https://github.com/ArduinoGetStarted/button denne github side]
<SyntaxHighlight lang="C">
#include <ezButton.h>

ezButton button(8);
</SyntaxHighlight>

==Software baseret på et andet bibliotek==
Softwaren er baseret på et bibliotek lavet af AdaFruit<ref>[https://github.com/adafruit/Adafruit_NeoPixel LED-Strip library udviklet af AdaFruit] placeret ved GitHub</ref>, og kan downloades som en ZIP-fil fra [https://github.com/adafruit/DHT-sensor-library Denne side], eller [[media:AdaFruit_NeuPixel-Master.zip|denne ZIP-fil]]. Biblioteket downloades og installeres som beskrevet under [[Arduinos_Biblioteker#Tilføjelse_af_biblioteker|Arduinos biblioteker]].

===Anvendelsen af softwaren===
Som alle andre biblioteker skal der sættes de grundlæggende ting op for at kontakte biblioteket og definere fugtsensoren, med ben og type osv.
<SyntaxHighlight lang="c">
#include <Adafruit_NeoPixel.h>

#define PIN 2 // input pin Neopixel is attached to

#define NUMPIXELS 18 // number of neopixels in strip

Adafruit_NeoPixel pixels1 = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
</SyntaxHighlight>

Til programmet anvendes enkelte variabler til styring af tid og farver:

<SyntaxHighlight lang="C">
int delayval = 100; // timing delay in milliseconds

byte R = 0; // Mængde af Rød (0 - 255)
byte G = 255; // Mængde af Grøn (0 - 255)
byte B = 0; // Mængde af Blå (0 - 255)
</SyntaxHighlight>

Inde i [[setup()]] skrives en velkomst og der skal sættes gang i objektet ved hjælp af begin-metoden som vist her:
<SyntaxHighlight lang="C">
void setup() {
Serial.begin(9600);
delay(200);
Serial.println("Demo af LED-Strip WS2812");
// Initialize the NeoPixel library.
pixels1.begin();
}
</SyntaxHighlight>

I [[loop()]] genneløbes en forløkke med alle LED'er, hvor farven sættes og vises, og efter et delay slukkes det igen:
<SyntaxHighlight lang="C">
void loop() {
for (int i=0; i < NUMPIXELS; i++) {
// pixels.Color takes RGB values, from 0,0,0 up to 255,255,255
pixels1.setPixelColor(i, pixels1.Color(R, G, B));

// This sends the updated pixel color to the hardware.
pixels1.show();

// Delay for a period of time (in milliseconds).
delay(delayval);

// Turn off the LED
pixels1.setPixelColor(i, pixels1.Color(0, 0, 0));
}
}
</SyntaxHighlight>

Koden laver et løbelys hen ad LED-Strippen, der gentages i det uendelige.

===Anvendelse af millis() i softwaren===
Koden i det viste eksempel anvender [[delay()]], hvilket gør at koden er blokeret det meste af tiden. Hvis man vil uden om dette, så er løsningen at anvende [[millis()]], der måler tiden på en anden måde, ved at bruge indbygget tidsmåling i Arduinoen.

Der er lavet et eksempel på kode med millis, hvor man med en knap kan stoppe og starte løbelyset på et hvilket som helst tidspunkt. Begge koder ligger i [[media:LED-Strip-kode.zip|Denne ZIP-fil]], og for at kunne anvende eksemplet med millis, så skal man have installeret ezButton biblioteket<ref>[https://www.arduino.cc/reference/en/libraries/ezbutton/ Arduinos omtale af] exButton</ref>. Dette kan hentes fra [https://github.com/ArduinoGetStarted/button denne github side]
<SyntaxHighlight lang="C">
#include <ezButton.h>

ezButton button(8);
</SyntaxHighlight>

==Hardware==
LED-Strip'en skal tilkobles programmerings-shieldet, så den får stel (GND) +5V forsyning og et signal, hvor der i den viste opstilling sættes en beskyttelsesmodstand i serie med signalet. LED-Strip'en kan i princippet forlænges efter ønske, og man vil stadig kunne tilgå hver enkelt LED. Det ligger i protokollen for den måde der kommunikeres med WS2812.

I det viste eksempel er der 18 LED'en koblet til, og hvis man tænder alle 18 med fuld kraft på Hvidt lys (alle farver skruet op), så kan man se at USB-porten har problemer med at forsyne Arduinoen - Power-LED'en bliver svagere, men den kan klare det uden at den resetter. Vil man arbejde med flere LED-Strips med mere lys i, så skal man overveje at tilføre ekstra forsyning. '''ADVARSEL''' - Hvis man sætter for høj en spænding på 5V forsyningen af Arduinoen, så kan det skade både Arduinoen OG en tilsluttet PC.

==Layout==
LED-Strippens placering på programmerings-shieldet kan ses her: 
[[fil:Layout-LED-Strip.png|600px]] 
''Placering af LED-Strip på Programmerings-Shieldet - HUSK at vende den rigtigt''

LED-Strippen placeres på pin 2, og vil på denne placering blokere for RF-Receiveren.
===Alternativ placering===
Hvis man ønsker at koble flere LED-Strips på Arduinoen, så kræver det en anden placering på programmerings-shieldet som det kan ses her: 
[[fil:Layout-LED-Strip-Alt.png|600px]] 
''Alternative placeringer af LED-Strips på Programmerings-Shieldet - HUSK at vende dem rigtigt - Output pin nummer angivet''

Man skal igen være opmærksom på hvor meget strøm man bruger - man kan evt. skrue ned for lysstyrken i hver enkelt LED.

Mulige ben med disse placeringer er pin 3, 8 og A5.

Disse placeringer blokerer så for Andre moduler, fordi benene genbruges.

==Referencer==
<references/>

{{template:prog-shield}}

[[Kategori:Programmerings-Shield]]

Rotary Encoder

2024-05-02T09:17:30Z

Bar: /* Kodeeksempel til Arduino */

[[Fil:Modul-24.jpg|thumb|right|200px|Billede af Rotary Encoder modul]]

Rotary Encoder modulet har et skaft på toppen, som kan roteres omkring en lodret akse. Dette skaft kan roteres uendeligt. Modulet kan registrere registrere skaftets rotationer.

Rotary encoders bliver brugt til mange processer, som kræver præcis uendelig rotation. Eksempelvis kan det bruges til computer mus med drejehjul, hvor det skal registreres i hvor meget kuglen drejer og i hvilke retninger. Det kan bruges til robotter, for at registrere hvor meget robotens motorer er drejet. Det kan også bruges i kamerar linser, for at undersøge hvor meget kameraret er zoomet ind.

Siden at modulet kan rotere uendeligt, har den ikke rigtigt nogen start eller slutning, men hvis man, i koden, holder styr på rotationen, så kan man bruge modulet bruges til at skrue op eller ned for noget, eksempelvis volumen af lyd eller styrken af lys lys. Rotary Encoder afgiver kun information når der bliver drejet på skaftet, den kan altså ikke fortælle nuværende position. Hvis man skal have en start position, skal man sætte skaftets nuværende position til start og så vil man derefter kunne skrue op eller ned. Modulet kan dog heller ikke gemme informationer, så når programmet bliver genstartet, vil den igen gøre skaftets nuværende position til start position. Så hvis man ønsker en position, som fast skal være start position, så skal man enten, aldrig lukke programmet eller sætte skaftets position tilbage til start før man starter sit program.

==Benforbindelser til modul==

{| class="wikitable" border="1"
|-
!Signal!!pin!!Pic-pin!!Forklaring
|-
|GND||1||10||Stel-forbindelse
|-
| + ||2||9||+ 5V forsyning
|-
|SW||3||5||Kontakt i Rotary Encoder, der trækker mod stel, når den trykkes ind
|-
|DT||4||4||Data signal - en del af rotations aftastning
|-
|CLK||5||3||Clock signal - en del af rotations aftastning
|}

==Princip-diagram for Rotary Encoder==
{|
|-
|valign="top"|

Selve rotary encoderen er vist som de to switche U$1 og U$2, hvor der sidder to pull-up modstande R2 og R3 der er monteret på printet.

Den sidste del er trykknappen S1, der sidder i drejeakslen, der kan aktiveres ved at trykke akslen indad.
På printet er der plads til en pull up, men den er ikke monteret, så den kan man eftermontere (SMD), eller man kan placere den uden for printet.

|valign="top"|
[[Image:Rotary_diagram.PNG|400px|Principskitse af Rotary Encoder]]
|}

===Forklaring til aflæsning af Rotary Encoder===
Når man drejer på Rotary Encoderen, så giver den to faseforskudte signaler ud, som vist her:

[[Image:Rotary_full_count.PNG|Tidsdiagram for Rotary Encoder med tælleskridt]]

Som det kan ses på tallene under kurverne, så tæller man et skridt hver gang der kommer en kant i signalerne fra enten CLK eller Data. Når Data er faseforskudt så den kommer efter CLK, så tælles der opad, og når faseforskydningen vender, så Data kommer før CLK, så tælles der nedad.

Mellem hvert "klik" på rotary encoderen tælles enten 4 gange op eller 4 gange ned.

Det kan man anvendelsesmæssigt håndtere ved at dividere tallet med 4.

Man kan også tælle lidt simplere, så man kun ændrer noget, hver gang CLK går fra lav til høj, som det er illustreret her:

[[Image:Rotary_single_count.PNG|Tidsdiagram for Rotary Encoder med enkelt tælling]]

Som det kan ses tælles der ved de positivt gående kanter på CLK, og der tælles op når Data er høj, og ned når Data er lav.

Dette princip virke umiddelbart enkelt, men det kan også have en ulempe, nemlig at der kan tælles forkert, hvis CLK giver flere positive kanter, men Data står på samme niveau, som det er illustreret her:

[[Image:Rotary_single_fejl.PNG|Tidsdiagram for Rotary Encoder med fejltælling]]

==Software modulet Rotary.jal==
Der ligger en servicerutine i Rotary modulet, hvor man kan få at vide om der er kommet en ny værdi, og den værdi kan aflæses i variablen Rotary_value, der er et signed word, som altså kan antage værdier fra -32768 til 32767.

Ved opstart står Rotary_value på 0.

Modulet kan anvende 4 forskellige principper.

Man kan vælge at arbejde med alle tælleskridt, så der kommer 80 på en omgang, men 4 trin for hvert "klik" på encoderen, eller man kan vælge at aflæse så der kommer 20 på en omgang, men med muligheden for at der opstår fejl.

Man kan også vælge om man vil servicere ved blot at kalde tit nok, eller om man vil lade en interrupt-rutine håndtere aflæsningen. Begge metoder kan kombineres frit uden begrænsninger.

===Anvendelse af Rotary Encoder===
Når man vil anvende Rotary Encoder modulet, så skal man [[include]] Rotary.jal som følger:

<source lang="jal">
include Rotary.jal
</source>

Hvis Rotary.jal ligger i \lib inde i c:\jalpack så kan compileren finde modulet.

[[JAL-fil]]en ligger sammen med et par eksempler inde i [[media:Rotary_jal.zip|en samlet ZIP-fil]]

Rotary er testet på følgende kombinationer:

{| class="wikitable" border="1"
|-
!PIC!!pin
|-
|[[PIC16F684]]||CLK=a2 DT=a3
|-
|[[PIC16F690]]||CLK=a2 DT=a3 - med alle kombinationer af interrupt og fuld/enkelt tælling
|}

===Interface fil til Rotary Encoder===
Man kan indstille de beskrevne ting i interfacefilen, samt man kan vælge hvilke indgange man ønsker at anvende til at aflæse encoderen med.

I Rotary_def.jal kan antallet af tælleskridt indstilles ved:
<source lang="jal">
Const rotary_single = false
</source>

False giver 4 skridt pr. klik og true giver 1 skridt pr. klik (kan lave fejl).

I Rotary_def.jal kan der indstilles om man skal bruge interrupt ved:
<source lang="jal">
Const rotary_interrupt = true
</source>

Placeringen af benene er lidt mere kompliceret, specielt på [[PIC16F690]], hvor man både kan bruge ben i PORTA og PORTB til det - dog med den begrænsning at man skal bruge to ben i samme port. 
Man angiver hvilken port det er med følgende angivelse:
<source lang="jal">
alias Rotary_port is porta
</source>

Som normalt skal man angive hvilke pins det er ved navnene. Her skal navngives CLK og Data, samt direction-benene for de samme:
<source lang="jal">
alias Rotary_pin_clk is pin_A2 -- clock pin
alias Rotary_pin_dt is pin_A3 -- data pin.
--
alias Rotary_pin_direction_clk is pin_A2_direction
alias Rotary_pin_direction_dt is pin_A3_direction
</source>

Til indstilling af interruptet skal man angive hvilke interrupt-indstillinger det er:
<source lang="jal">
alias Rotary_int_clk is IOCA_IOCA2
alias Rotary_int_dt is IOCA_IOCA3
</source>

Endelig skal der kunne angives hvilke bit det er i de spejlede variabler inde i rutinerne, og det gøres blot ved at angive bit-nummeret som vist her:
<source lang="jal">
const Rotary_clk_bit = 2
const Rotary_dt_bit = 3
</source>

==Anvendelsen af Rotary Encoder==

Man skal foretage valgene omkring interrupt ud fra om man lave sin kode så modulet serviceres meget ofte, og om man skal have visning på alle nye værdier, samt om man må miste værdier (om man har et fast nul-punkt).

Så skal man vælge om man vil have alle tælleskridt med, eller om man vil have 1 tælleskridt pr. klik, med den ulempe, at man kan få falske tællinger.

Ud over det er anvendelsen ret simpel:
<source lang="jal">
include Rorary.jal

forever loop
if new_rotary_value then
rotary_value -- anvend den nye værdi til noget fornuftigt
end if
--
-- Her kan placeres anden kode i loopet, der skal lave andre ting
--
end loop
</source>

==Forklaring af Rotary software==

Her forklares i detaljer hvordan modulet fungerer inde i software-modulet

===Initialisering af softwaren===

Initialiseringen kan i [[Pseudokode]] udtrykkes som følger:

<pre>
Læs opsætningen i Rotary_def.jal
Sæt Rotary_value til 0
indstil interruptet, hvis det skal anvendes
</pre>

===Funktionen new_rotary_value===

Funktionen kaldes ofte, og når der er en ny værdi, så returnerer den true, og man kan aflæse status på tælleren i rotary_value.

Hvis man ikke anvender interrupt, så skal funktionen kaldes så ofte, at man ikke mister tælleskridt. Anvender man interruptet, så vil der blot ligge den værdi man er kommet til.

===Konstanterne i interface-filen===
Det er mest af alt de indstillinger der er beskrevet tidligere.

===Funktionsbeskrivelse===

Princippet for at registrere tælling af enkelt skridt kan i [[pseudokode]] udtrykkes som følger:
<pre>
Hvis der er en forkant på CLK så
Marker at der er sket en ændring
Hvis Data er høj så
Tæl en op
ellers
Tæl en ned
</pre>

Dette kan ske direkte i servicerutinen, eller hvis det er med interrupt, så sker det ved at registreringen sker i interruptet, og servicerutinen registrerer at det er sket.

På samme måde laves tællingen på alle kanter enten i interruptet eller i servicerutinen. 
Som pseudokode er det lidt mere kompliceret:
<pre>
Hvis der er sket et skift på CLK så
Marker at der er sket en ændring
Hvis CLK er Høj så
Hvis Data er høj så
Tæl en op
Ellers
Tæl en ned
Ellers
Hvis Data er høj så
Tæl en ned
Ellers
Tæl en op
Ellers
Hvis der er sket et skift på Data så
Marker at der er sket en ændring
Hvis Data er Høj så
Hvis CLK er høj så
Tæl en ned
Ellers
Tæl en op
Ellers
Hvis CLK er høj så
Tæl en op
Ellers
Tæl en ned

</pre>

===Koden inde i funktionerne===

Koden er ret uoverskuelig, specielt fordi den skal kunne fungere på 4 forskellige måder, ud fra de indstillinger der er lavet i interface-filen.

Det er også således at noget løses i interrupt, mens andet løses i servicerutinen.

Koden ligger sammen med eksempler og en demo inde i [[media:Rotary_jal.zip|en samlet ZIP-fil]].

==Kodeeksempel til Arduino==
Dette eksempel er givet for at vise hvordan Rotary Encoderen kan anvendes til Arduino.

Den konkrete kode tager udgangspunkt i pseudokoden, og bliver ikke forklaret i detaljer, men der forklares de ting, der har er specielt for denne kode.

<syntaxHighlight lang="C">
#define CLK_PIN 3
#define DT_PIN 4

int countValue = 0;
bool lastClk;
bool lastDt;

void setup() {
pinMode(CLK_PIN, INPUT);
pinMode(DT_PIN, INPUT);
Serial.begin(500000);
delay(100);
Serial.println("\r\nRotary Switch Simple demo");
lastClk = digitalRead(CLK_PIN);
lastDt = digitalRead(DT_PIN);
}

void printCount() {
Serial.print("Count:\t");
Serial.print(countValue);
int countClick = countValue / 4;
Serial.print("\t");
Serial.println(countClick);
}

void loop() {
bool clkNow = digitalRead(CLK_PIN);
bool dtNow = digitalRead(DT_PIN);
if (clkNow != lastClk) {
if (clkNow) {
if (dtNow) {
countValue++;
} else {
countValue--;
}
} else {
if (dtNow) {
countValue--;
} else {
countValue++;
}
}
lastClk = clkNow;
printCount();
}
if (dtNow != lastDt) {
if (dtNow) {
if (clkNow) {
countValue--;
} else {
countValue++;
}
} else {
if (clkNow) {
countValue++;
} else {
countValue--;
}
}
lastDt = dtNow;
printCount();
}
}
</syntaxHighlight>

Koden læser alle skift på de to signaler CLK og DT, og som Rotary Encoderen (den der er testet til koden) er opbygget, så for hvert klik der er i omgangen (20 klik i alt), så er der 4 skift. Når koden skriver ud i Serial monitor, så kommer der udskrift på alle kanter.

Udskriften viser to værdier - tællingen på kanterne og så den tælling delt med 4, som modsvarer de klik der er i Rotary Encoderen.
Hvis man kun ønskede udskrift for hvert klik, så kunne man i funktionen printCount() tilføje en linje, så den kommer til at se ud på følgende måde:
<syntaxHighlight lang="C">
void printCount() {
if ((countValue % 4) != 0) return;
Serial.print("Count:\t");
Serial.print(countValue);
int countClick = countValue / 4;
Serial.print("\t");
Serial.println(countClick);
}
</syntaxHighlight>

I setup() sættes den serielle Baud Rate til 500000. Grunden til dette er at koden i loop() er tidsfølsom, forstået på den måde, at hvis der er noget i loop() der tager lang tid, så kan koden springe over kanter, og dermed ikke tælle rigtigt. Dette blev observeret ved en Baud Rate på 9600, hvor det der skulle skrives ud kom til at vente på at der blev skrevet ud, så signaler blev sprunget over. Måden det blev konstateret var at markere et nulpunkt, og så dreje stille og roligt fx 2 omgange. Dette gav som forventet 160 kanter. Ved så at køre hurtigt to omgange retur skulle man forvente at tallet kom tilbage på 0 - dette var ikke tilfældet, altså var der kanter der blev sprunget over.

Med ovenstående erfaring, så skal man være meget opmærksom på tid i udvikling af software, specielt hvis Rotary Encoderen skal kunne fungere i alle situationer. Man skal passe på med alt - specielt delay() må man bare ikke have i koden så den fungerer på tidspunkter hvor der skal kunne registreres fra Rotary Encoderen, med også display-rutiner LED-strip og mange andre ting vil kunne give problemer. Er man i tvivl vil man kunne lave en test som beskrevet ovenfor.

Alternativt skal man skrive koden om, så den fungerer på interrupt. Dette er ikke dokumenteret her.

{{moduler}}

{{keyes-moduler}}

[[Kategori:Flere digitale signaler]]
[[Kategori:JAL-moduler]]

Rotary Encoder

2024-05-02T07:07:01Z

Bar:

[[Fil:Modul-24.jpg|thumb|right|200px|Billede af Rotary Encoder modul]]

Rotary Encoder modulet har et skaft på toppen, som kan roteres omkring en lodret akse. Dette skaft kan roteres uendeligt. Modulet kan registrere registrere skaftets rotationer.

Rotary encoders bliver brugt til mange processer, som kræver præcis uendelig rotation. Eksempelvis kan det bruges til computer mus med drejehjul, hvor det skal registreres i hvor meget kuglen drejer og i hvilke retninger. Det kan bruges til robotter, for at registrere hvor meget robotens motorer er drejet. Det kan også bruges i kamerar linser, for at undersøge hvor meget kameraret er zoomet ind.

Siden at modulet kan rotere uendeligt, har den ikke rigtigt nogen start eller slutning, men hvis man, i koden, holder styr på rotationen, så kan man bruge modulet bruges til at skrue op eller ned for noget, eksempelvis volumen af lyd eller styrken af lys lys. Rotary Encoder afgiver kun information når der bliver drejet på skaftet, den kan altså ikke fortælle nuværende position. Hvis man skal have en start position, skal man sætte skaftets nuværende position til start og så vil man derefter kunne skrue op eller ned. Modulet kan dog heller ikke gemme informationer, så når programmet bliver genstartet, vil den igen gøre skaftets nuværende position til start position. Så hvis man ønsker en position, som fast skal være start position, så skal man enten, aldrig lukke programmet eller sætte skaftets position tilbage til start før man starter sit program.

==Benforbindelser til modul==

{| class="wikitable" border="1"
|-
!Signal!!pin!!Pic-pin!!Forklaring
|-
|GND||1||10||Stel-forbindelse
|-
| + ||2||9||+ 5V forsyning
|-
|SW||3||5||Kontakt i Rotary Encoder, der trækker mod stel, når den trykkes ind
|-
|DT||4||4||Data signal - en del af rotations aftastning
|-
|CLK||5||3||Clock signal - en del af rotations aftastning
|}

==Princip-diagram for Rotary Encoder==
{|
|-
|valign="top"|

Selve rotary encoderen er vist som de to switche U$1 og U$2, hvor der sidder to pull-up modstande R2 og R3 der er monteret på printet.

Den sidste del er trykknappen S1, der sidder i drejeakslen, der kan aktiveres ved at trykke akslen indad.
På printet er der plads til en pull up, men den er ikke monteret, så den kan man eftermontere (SMD), eller man kan placere den uden for printet.

|valign="top"|
[[Image:Rotary_diagram.PNG|400px|Principskitse af Rotary Encoder]]
|}

===Forklaring til aflæsning af Rotary Encoder===
Når man drejer på Rotary Encoderen, så giver den to faseforskudte signaler ud, som vist her:

[[Image:Rotary_full_count.PNG|Tidsdiagram for Rotary Encoder med tælleskridt]]

Som det kan ses på tallene under kurverne, så tæller man et skridt hver gang der kommer en kant i signalerne fra enten CLK eller Data. Når Data er faseforskudt så den kommer efter CLK, så tælles der opad, og når faseforskydningen vender, så Data kommer før CLK, så tælles der nedad.

Mellem hvert "klik" på rotary encoderen tælles enten 4 gange op eller 4 gange ned.

Det kan man anvendelsesmæssigt håndtere ved at dividere tallet med 4.

Man kan også tælle lidt simplere, så man kun ændrer noget, hver gang CLK går fra lav til høj, som det er illustreret her:

[[Image:Rotary_single_count.PNG|Tidsdiagram for Rotary Encoder med enkelt tælling]]

Som det kan ses tælles der ved de positivt gående kanter på CLK, og der tælles op når Data er høj, og ned når Data er lav.

Dette princip virke umiddelbart enkelt, men det kan også have en ulempe, nemlig at der kan tælles forkert, hvis CLK giver flere positive kanter, men Data står på samme niveau, som det er illustreret her:

[[Image:Rotary_single_fejl.PNG|Tidsdiagram for Rotary Encoder med fejltælling]]

==Software modulet Rotary.jal==
Der ligger en servicerutine i Rotary modulet, hvor man kan få at vide om der er kommet en ny værdi, og den værdi kan aflæses i variablen Rotary_value, der er et signed word, som altså kan antage værdier fra -32768 til 32767.

Ved opstart står Rotary_value på 0.

Modulet kan anvende 4 forskellige principper.

Man kan vælge at arbejde med alle tælleskridt, så der kommer 80 på en omgang, men 4 trin for hvert "klik" på encoderen, eller man kan vælge at aflæse så der kommer 20 på en omgang, men med muligheden for at der opstår fejl.

Man kan også vælge om man vil servicere ved blot at kalde tit nok, eller om man vil lade en interrupt-rutine håndtere aflæsningen. Begge metoder kan kombineres frit uden begrænsninger.

===Anvendelse af Rotary Encoder===
Når man vil anvende Rotary Encoder modulet, så skal man [[include]] Rotary.jal som følger:

<source lang="jal">
include Rotary.jal
</source>

Hvis Rotary.jal ligger i \lib inde i c:\jalpack så kan compileren finde modulet.

[[JAL-fil]]en ligger sammen med et par eksempler inde i [[media:Rotary_jal.zip|en samlet ZIP-fil]]

Rotary er testet på følgende kombinationer:

{| class="wikitable" border="1"
|-
!PIC!!pin
|-
|[[PIC16F684]]||CLK=a2 DT=a3
|-
|[[PIC16F690]]||CLK=a2 DT=a3 - med alle kombinationer af interrupt og fuld/enkelt tælling
|}

===Interface fil til Rotary Encoder===
Man kan indstille de beskrevne ting i interfacefilen, samt man kan vælge hvilke indgange man ønsker at anvende til at aflæse encoderen med.

I Rotary_def.jal kan antallet af tælleskridt indstilles ved:
<source lang="jal">
Const rotary_single = false
</source>

False giver 4 skridt pr. klik og true giver 1 skridt pr. klik (kan lave fejl).

I Rotary_def.jal kan der indstilles om man skal bruge interrupt ved:
<source lang="jal">
Const rotary_interrupt = true
</source>

Placeringen af benene er lidt mere kompliceret, specielt på [[PIC16F690]], hvor man både kan bruge ben i PORTA og PORTB til det - dog med den begrænsning at man skal bruge to ben i samme port. 
Man angiver hvilken port det er med følgende angivelse:
<source lang="jal">
alias Rotary_port is porta
</source>

Som normalt skal man angive hvilke pins det er ved navnene. Her skal navngives CLK og Data, samt direction-benene for de samme:
<source lang="jal">
alias Rotary_pin_clk is pin_A2 -- clock pin
alias Rotary_pin_dt is pin_A3 -- data pin.
--
alias Rotary_pin_direction_clk is pin_A2_direction
alias Rotary_pin_direction_dt is pin_A3_direction
</source>

Til indstilling af interruptet skal man angive hvilke interrupt-indstillinger det er:
<source lang="jal">
alias Rotary_int_clk is IOCA_IOCA2
alias Rotary_int_dt is IOCA_IOCA3
</source>

Endelig skal der kunne angives hvilke bit det er i de spejlede variabler inde i rutinerne, og det gøres blot ved at angive bit-nummeret som vist her:
<source lang="jal">
const Rotary_clk_bit = 2
const Rotary_dt_bit = 3
</source>

==Anvendelsen af Rotary Encoder==

Man skal foretage valgene omkring interrupt ud fra om man lave sin kode så modulet serviceres meget ofte, og om man skal have visning på alle nye værdier, samt om man må miste værdier (om man har et fast nul-punkt).

Så skal man vælge om man vil have alle tælleskridt med, eller om man vil have 1 tælleskridt pr. klik, med den ulempe, at man kan få falske tællinger.

Ud over det er anvendelsen ret simpel:
<source lang="jal">
include Rorary.jal

forever loop
if new_rotary_value then
rotary_value -- anvend den nye værdi til noget fornuftigt
end if
--
-- Her kan placeres anden kode i loopet, der skal lave andre ting
--
end loop
</source>

==Forklaring af Rotary software==

Her forklares i detaljer hvordan modulet fungerer inde i software-modulet

===Initialisering af softwaren===

Initialiseringen kan i [[Pseudokode]] udtrykkes som følger:

<pre>
Læs opsætningen i Rotary_def.jal
Sæt Rotary_value til 0
indstil interruptet, hvis det skal anvendes
</pre>

===Funktionen new_rotary_value===

Funktionen kaldes ofte, og når der er en ny værdi, så returnerer den true, og man kan aflæse status på tælleren i rotary_value.

Hvis man ikke anvender interrupt, så skal funktionen kaldes så ofte, at man ikke mister tælleskridt. Anvender man interruptet, så vil der blot ligge den værdi man er kommet til.

===Konstanterne i interface-filen===
Det er mest af alt de indstillinger der er beskrevet tidligere.

===Funktionsbeskrivelse===

Princippet for at registrere tælling af enkelt skridt kan i [[pseudokode]] udtrykkes som følger:
<pre>
Hvis der er en forkant på CLK så
Marker at der er sket en ændring
Hvis Data er høj så
Tæl en op
ellers
Tæl en ned
</pre>

Dette kan ske direkte i servicerutinen, eller hvis det er med interrupt, så sker det ved at registreringen sker i interruptet, og servicerutinen registrerer at det er sket.

På samme måde laves tællingen på alle kanter enten i interruptet eller i servicerutinen. 
Som pseudokode er det lidt mere kompliceret:
<pre>
Hvis der er sket et skift på CLK så
Marker at der er sket en ændring
Hvis CLK er Høj så
Hvis Data er høj så
Tæl en op
Ellers
Tæl en ned
Ellers
Hvis Data er høj så
Tæl en ned
Ellers
Tæl en op
Ellers
Hvis der er sket et skift på Data så
Marker at der er sket en ændring
Hvis Data er Høj så
Hvis CLK er høj så
Tæl en ned
Ellers
Tæl en op
Ellers
Hvis CLK er høj så
Tæl en op
Ellers
Tæl en ned

</pre>

===Koden inde i funktionerne===

Koden er ret uoverskuelig, specielt fordi den skal kunne fungere på 4 forskellige måder, ud fra de indstillinger der er lavet i interface-filen.

Det er også således at noget løses i interrupt, mens andet løses i servicerutinen.

Koden ligger sammen med eksempler og en demo inde i [[media:Rotary_jal.zip|en samlet ZIP-fil]].

==Kodeeksempel til Arduino==
Dette eksempel er givet for at vise hvordan Rotary Encoderen kan anvendes til Arduino.

Den konkrete kode tager udgangspunkt i pseudokoden, og bliver ikke forklaret i detaljer, men der forklares de ting, der har er specielt for denne kode.

<syntaxHighlight lang="C">
#define CLK_PIN 3
#define DT_PIN 4

int countValue = 0;
bool lastClk;
bool lastDt;

void setup() {
pinMode(CLK_PIN, INPUT);
pinMode(DT_PIN, INPUT);
Serial.begin(500000);
delay(100);
Serial.println("\r\nRotary Switch Simple demo");
lastClk = digitalRead(CLK_PIN);
lastDt = digitalRead(DT_PIN);
}

void printCount() {
Serial.print("Count:\t");
Serial.print(countValue);
int countClick = countValue / 4;
Serial.print("\t");
Serial.println(countClick);
}

void loop() {
bool clkNow = digitalRead(CLK_PIN);
bool dtNow = digitalRead(DT_PIN);
if (clkNow != lastClk) {
if (clkNow) {
if (dtNow) {
countValue++;
} else {
countValue--;
}
} else {
if (dtNow) {
countValue--;
} else {
countValue++;
}
}
lastClk = clkNow;
printCount();
}
if (dtNow != lastDt) {
if (dtNow) {
if (clkNow) {
countValue--;
} else {
countValue++;
}
} else {
if (clkNow) {
countValue++;
} else {
countValue--;
}
}
lastDt = dtNow;
printCount();
}
}
</syntaxHighlight>

Koden læser alle skift på de to signaler CLK og DT, og som Rotary Encoderen (den der er testet til koden) er opbygget, så for hvert klik der er i omgangen (20 klik i alt), så er der 4 skift. Når koden skriver ud i Serial monitor, så kommer der udskrift på alle kanter.

Udskriften viser to værdier - tællingen på kanterne og så den tælling delt med 4, som modsvarer de klik der er i Rotary Encoderen.
Hvis man kun ønskede udskrift for hvert klik, så kunne man i funktionen printCount() starte med følgende linje:
<syntaxHighlight lang="C">
if ((countValue % 4) != 0) return;
</syntaxHighlight>

I setup() sættes den serielle Baud Rate til 500000. Grunden til dette er at koden i loop() er tidsfølsom, forstået på den måde, at hvis der er noget i loop() der tager lang tid, så kan koden springe over kanter, og dermed ikke tælle rigtigt. Dette blev observeret ved en Baud Rate på 9600, hvor det der skulle skrives ud kom til at vente på at der blev skrevet ud, så signaler blev sprunget over. Måden det blev konstateret var at markere et nulpunkt, og så dreje stille og roligt fx 2 omgange. Dette gav som forventet 160 kanter. Ved så at køre hurtigt to omgange retur skulle man forvente at tallet kom tilbage på 0 - dette var ikke tilfældet, altså var der kanter der blev sprunget over.
{{moduler}}

{{keyes-moduler}}

[[Kategori:Flere digitale signaler]]
[[Kategori:JAL-moduler]]

Rotary Encoder

2024-05-02T06:45:51Z

Bar: /* Koden inde i funktionerne */

[[Fil:Modul-24.jpg|thumb|right|200px|Billede af Rotary Encoder modul]]

Rotary Encoder modulet har et skaft på toppen, som kan roteres omkring en lodret akse. Dette skaft kan roteres uendeligt. Modulet kan registrere registrere skaftets rotationer.

Rotary encoders bliver brugt til mange processer, som kræver præcis uendelig rotation. Eksempelvis kan det bruges til computer mus med drejehjul, hvor det skal registreres i hvor meget kuglen drejer og i hvilke retninger. Det kan bruges til robotter, for at registrere hvor meget robotens motorer er drejet. Det kan også bruges i kamerar linser, for at undersøge hvor meget kameraret er zoomet ind.

Siden at modulet kan rotere uendeligt, har den ikke rigtigt nogen start eller slutning, men hvis man, i koden, holder styr på rotationen, så kan man bruge modulet bruges til at skrue op eller ned for noget, eksempelvis volumen af lyd eller styrken af lys lys. Rotary Encoder afgiver kun information når der bliver drejet på skaftet, den kan altså ikke fortælle nuværende position. Hvis man skal have en start position, skal man sætte skaftets nuværende position til start og så vil man derefter kunne skrue op eller ned. Modulet kan dog heller ikke gemme informationer, så når programmet bliver genstartet, vil den igen gøre skaftets nuværende position til start position. Så hvis man ønsker en position, som fast skal være start position, så skal man enten, aldrig lukke programmet eller sætte skaftets position tilbage til start før man starter sit program.

==Benforbindelser til modul==

{| class="wikitable" border="1"
|-
!Signal!!pin!!Pic-pin!!Forklaring
|-
|GND||1||10||Stel-forbindelse
|-
| + ||2||9||+ 5V forsyning
|-
|SW||3||5||Kontakt i Rotary Encoder, der trækker mod stel, når den trykkes ind
|-
|DT||4||4||Data signal - en del af rotations aftastning
|-
|CLK||5||3||Clock signal - en del af rotations aftastning
|}

==Princip-diagram for Rotary Encoder==
{|
|-
|valign="top"|

Selve rotary encoderen er vist som de to switche U$1 og U$2, hvor der sidder to pull-up modstande R2 og R3 der er monteret på printet.

Den sidste del er trykknappen S1, der sidder i drejeakslen, der kan aktiveres ved at trykke akslen indad.
På printet er der plads til en pull up, men den er ikke monteret, så den kan man eftermontere (SMD), eller man kan placere den uden for printet.

|valign="top"|
[[Image:Rotary_diagram.PNG|400px|Principskitse af Rotary Encoder]]
|}

===Forklaring til aflæsning af Rotary Encoder===
Når man drejer på Rotary Encoderen, så giver den to faseforskudte signaler ud, som vist her:

[[Image:Rotary_full_count.PNG|Tidsdiagram for Rotary Encoder med tælleskridt]]

Som det kan ses på tallene under kurverne, så tæller man et skridt hver gang der kommer en kant i signalerne fra enten CLK eller Data. Når Data er faseforskudt så den kommer efter CLK, så tælles der opad, og når faseforskydningen vender, så Data kommer før CLK, så tælles der nedad.

Mellem hvert "klik" på rotary encoderen tælles enten 4 gange op eller 4 gange ned.

Det kan man anvendelsesmæssigt håndtere ved at dividere tallet med 4.

Man kan også tælle lidt simplere, så man kun ændrer noget, hver gang CLK går fra lav til høj, som det er illustreret her:

[[Image:Rotary_single_count.PNG|Tidsdiagram for Rotary Encoder med enkelt tælling]]

Som det kan ses tælles der ved de positivt gående kanter på CLK, og der tælles op når Data er høj, og ned når Data er lav.

Dette princip virke umiddelbart enkelt, men det kan også have en ulempe, nemlig at der kan tælles forkert, hvis CLK giver flere positive kanter, men Data står på samme niveau, som det er illustreret her:

[[Image:Rotary_single_fejl.PNG|Tidsdiagram for Rotary Encoder med fejltælling]]

==Software modulet Rotary.jal==
Der ligger en servicerutine i Rotary modulet, hvor man kan få at vide om der er kommet en ny værdi, og den værdi kan aflæses i variablen Rotary_value, der er et signed word, som altså kan antage værdier fra -32768 til 32767.

Ved opstart står Rotary_value på 0.

Modulet kan anvende 4 forskellige principper.

Man kan vælge at arbejde med alle tælleskridt, så der kommer 80 på en omgang, men 4 trin for hvert "klik" på encoderen, eller man kan vælge at aflæse så der kommer 20 på en omgang, men med muligheden for at der opstår fejl.

Man kan også vælge om man vil servicere ved blot at kalde tit nok, eller om man vil lade en interrupt-rutine håndtere aflæsningen. Begge metoder kan kombineres frit uden begrænsninger.

===Anvendelse af Rotary Encoder===
Når man vil anvende Rotary Encoder modulet, så skal man [[include]] Rotary.jal som følger:

<source lang="jal">
include Rotary.jal
</source>

Hvis Rotary.jal ligger i \lib inde i c:\jalpack så kan compileren finde modulet.

[[JAL-fil]]en ligger sammen med et par eksempler inde i [[media:Rotary_jal.zip|en samlet ZIP-fil]]

Rotary er testet på følgende kombinationer:

{| class="wikitable" border="1"
|-
!PIC!!pin
|-
|[[PIC16F684]]||CLK=a2 DT=a3
|-
|[[PIC16F690]]||CLK=a2 DT=a3 - med alle kombinationer af interrupt og fuld/enkelt tælling
|}

===Interface fil til Rotary Encoder===
Man kan indstille de beskrevne ting i interfacefilen, samt man kan vælge hvilke indgange man ønsker at anvende til at aflæse encoderen med.

I Rotary_def.jal kan antallet af tælleskridt indstilles ved:
<source lang="jal">
Const rotary_single = false
</source>

False giver 4 skridt pr. klik og true giver 1 skridt pr. klik (kan lave fejl).

I Rotary_def.jal kan der indstilles om man skal bruge interrupt ved:
<source lang="jal">
Const rotary_interrupt = true
</source>

Placeringen af benene er lidt mere kompliceret, specielt på [[PIC16F690]], hvor man både kan bruge ben i PORTA og PORTB til det - dog med den begrænsning at man skal bruge to ben i samme port. 
Man angiver hvilken port det er med følgende angivelse:
<source lang="jal">
alias Rotary_port is porta
</source>

Som normalt skal man angive hvilke pins det er ved navnene. Her skal navngives CLK og Data, samt direction-benene for de samme:
<source lang="jal">
alias Rotary_pin_clk is pin_A2 -- clock pin
alias Rotary_pin_dt is pin_A3 -- data pin.
--
alias Rotary_pin_direction_clk is pin_A2_direction
alias Rotary_pin_direction_dt is pin_A3_direction
</source>

Til indstilling af interruptet skal man angive hvilke interrupt-indstillinger det er:
<source lang="jal">
alias Rotary_int_clk is IOCA_IOCA2
alias Rotary_int_dt is IOCA_IOCA3
</source>

Endelig skal der kunne angives hvilke bit det er i de spejlede variabler inde i rutinerne, og det gøres blot ved at angive bit-nummeret som vist her:
<source lang="jal">
const Rotary_clk_bit = 2
const Rotary_dt_bit = 3
</source>

==Anvendelsen af Rotary Encoder==

Man skal foretage valgene omkring interrupt ud fra om man lave sin kode så modulet serviceres meget ofte, og om man skal have visning på alle nye værdier, samt om man må miste værdier (om man har et fast nul-punkt).

Så skal man vælge om man vil have alle tælleskridt med, eller om man vil have 1 tælleskridt pr. klik, med den ulempe, at man kan få falske tællinger.

Ud over det er anvendelsen ret simpel:
<source lang="jal">
include Rorary.jal

forever loop
if new_rotary_value then
rotary_value -- anvend den nye værdi til noget fornuftigt
end if
--
-- Her kan placeres anden kode i loopet, der skal lave andre ting
--
end loop
</source>

==Forklaring af Rotary software==

Her forklares i detaljer hvordan modulet fungerer inde i software-modulet

===Initialisering af softwaren===

Initialiseringen kan i [[Pseudokode]] udtrykkes som følger:

<pre>
Læs opsætningen i Rotary_def.jal
Sæt Rotary_value til 0
indstil interruptet, hvis det skal anvendes
</pre>

===Funktionen new_rotary_value===

Funktionen kaldes ofte, og når der er en ny værdi, så returnerer den true, og man kan aflæse status på tælleren i rotary_value.

Hvis man ikke anvender interrupt, så skal funktionen kaldes så ofte, at man ikke mister tælleskridt. Anvender man interruptet, så vil der blot ligge den værdi man er kommet til.

===Konstanterne i interface-filen===
Det er mest af alt de indstillinger der er beskrevet tidligere.

===Funktionsbeskrivelse===

Princippet for at registrere tælling af enkelt skridt kan i [[pseudokode]] udtrykkes som følger:
<pre>
Hvis der er en forkant på CLK så
Marker at der er sket en ændring
Hvis Data er høj så
Tæl en op
ellers
Tæl en ned
</pre>

Dette kan ske direkte i servicerutinen, eller hvis det er med interrupt, så sker det ved at registreringen sker i interruptet, og servicerutinen registrerer at det er sket.

På samme måde laves tællingen på alle kanter enten i interruptet eller i servicerutinen. 
Som pseudokode er det lidt mere kompliceret:
<pre>
Hvis der er sket et skift på CLK så
Marker at der er sket en ændring
Hvis CLK er Høj så
Hvis Data er høj så
Tæl en op
Ellers
Tæl en ned
Ellers
Hvis Data er høj så
Tæl en ned
Ellers
Tæl en op
Ellers
Hvis der er sket et skift på Data så
Marker at der er sket en ændring
Hvis Data er Høj så
Hvis CLK er høj så
Tæl en ned
Ellers
Tæl en op
Ellers
Hvis CLK er høj så
Tæl en op
Ellers
Tæl en ned

</pre>

===Koden inde i funktionerne===

Koden er ret uoverskuelig, specielt fordi den skal kunne fungere på 4 forskellige måder, ud fra de indstillinger der er lavet i interface-filen.

Det er også således at noget løses i interrupt, mens andet løses i servicerutinen.

Koden ligger sammen med eksempler og en demo inde i [[media:Rotary_jal.zip|en samlet ZIP-fil]].

==Kodeeksempel til Arduino==
Dette eksempel er givet for at vise hvordan Rotary Encoderen kan anvendes til Arduino.

Den konkrete kode tager udgangspunkt i pseudokoden, og bliver ikke forklaret i detaljer, men der forklares de ting, der har er specielt for denne kode.

{{moduler}}

{{keyes-moduler}}

[[Kategori:Flere digitale signaler]]
[[Kategori:JAL-moduler]]

Programmering med ChatGPT

2024-04-30T10:50:53Z

Bar: /* Den meget nemmere metode */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i et skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.

==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære at programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

: Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
: Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
: [Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023)<ref>[https://chat.openai.com/chat Indgangen til ChatGPT 3.5]</ref> der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024)<ref>[https://processing.org Hovedsiden for Processing]</ref> og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

Når man opretter kilden i Word, så er det lidt forskelligt hvilke felter der er synlige, alt efter hvilken standard man har aktiv - men ved Harvard-Anglia standarden kan indtastningerne se således ud:

[[fil:citat-ChatGPT.png|Indtastningerne ved kildehenvisning til ChatGPT|600px]] ''Indtastningerne ved kildehenvisning til ChatGPT''

Mere om teknikken i at anvende kildelister kan ses på [https://holstebro-htx.dk/index.php/Word_Kildeliste Holstebro HTX Wiki - Kildelister].

====Den meget nemmere metode====
Tingene udvikler sig hele tiden, og nu kan man faktisk få et link til den dialog man har haft med ChatGPT 3.5. Hvordan andre sprogmodeller fungerer må man selv eksperimentere sig frem til.

Måden man gør det på er, at man klikker på en ikon i øverste højre side af websiden med den dialog man gerne vil linke til, som vist herunder, hvor man kommer i en dialog, så man kan kopiere linket. 
[[fil:link_til_chatGPT.png|Link ikon til dialog i chatGPT]] 
''Link ikon til dialog i chatGPT''

Selve linket ser ud som følger: https://chat.openai.com/share/90e9607f-bff9-40d1-a68c-9617051e9615.

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive den foreslåede constructor til følgende kode, hvor bolden placeres mindst en halv diameter fra kanten:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Refleksioner over anvendelsen==
Der er selvfølgelig stadig lang vej til man har et færdigt spil, men ideen var også at tage fat i, hvordan man anvender ChatGPT på en ordentlig og redelig måde i et programmeringsprojekt. Dette kan selvfølgelig altid gradbøjes, men hvis man håndterer anvendelsen som vist i eksemplet, så vil man ikke gøre noget der kommer i nærheden af plagiat.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-04-30T10:50:07Z

Bar: /* Den meget nemmere metode */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i et skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.

==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære at programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

: Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
: Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
: [Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023)<ref>[https://chat.openai.com/chat Indgangen til ChatGPT 3.5]</ref> der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024)<ref>[https://processing.org Hovedsiden for Processing]</ref> og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

Når man opretter kilden i Word, så er det lidt forskelligt hvilke felter der er synlige, alt efter hvilken standard man har aktiv - men ved Harvard-Anglia standarden kan indtastningerne se således ud:

[[fil:citat-ChatGPT.png|Indtastningerne ved kildehenvisning til ChatGPT|600px]] ''Indtastningerne ved kildehenvisning til ChatGPT''

Mere om teknikken i at anvende kildelister kan ses på [https://holstebro-htx.dk/index.php/Word_Kildeliste Holstebro HTX Wiki - Kildelister].

====Den meget nemmere metode====
Tingene udvikler sig hele tiden, og nu kan man faktisk få et link til den dialog man har haft med ChatGPT 3.5.

Måden man gør det på er, at man klikker på en ikon i øverste højre side af websiden med den dialog man gerne vil linke til, som vist herunder, hvor man kommer i en dialog, så man kan kopiere linket. 
[[fil:link_til_chatGPT.png|Link ikon til dialog i chatGPT]] 
''Link ikon til dialog i chatGPT''

Selve linket ser ud som følger: https://chat.openai.com/share/90e9607f-bff9-40d1-a68c-9617051e9615.

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive den foreslåede constructor til følgende kode, hvor bolden placeres mindst en halv diameter fra kanten:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Refleksioner over anvendelsen==
Der er selvfølgelig stadig lang vej til man har et færdigt spil, men ideen var også at tage fat i, hvordan man anvender ChatGPT på en ordentlig og redelig måde i et programmeringsprojekt. Dette kan selvfølgelig altid gradbøjes, men hvis man håndterer anvendelsen som vist i eksemplet, så vil man ikke gøre noget der kommer i nærheden af plagiat.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-04-30T10:48:53Z

Bar: /* Den meget nemmere metode */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i et skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.

==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære at programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

: Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
: Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
: [Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023)<ref>[https://chat.openai.com/chat Indgangen til ChatGPT 3.5]</ref> der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024)<ref>[https://processing.org Hovedsiden for Processing]</ref> og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

Når man opretter kilden i Word, så er det lidt forskelligt hvilke felter der er synlige, alt efter hvilken standard man har aktiv - men ved Harvard-Anglia standarden kan indtastningerne se således ud:

[[fil:citat-ChatGPT.png|Indtastningerne ved kildehenvisning til ChatGPT|600px]] ''Indtastningerne ved kildehenvisning til ChatGPT''

Mere om teknikken i at anvende kildelister kan ses på [https://holstebro-htx.dk/index.php/Word_Kildeliste Holstebro HTX Wiki - Kildelister].

====Den meget nemmere metode====
Tingene udvikler sig hele tiden, og nu kan man faktisk få et link til den dialog man har haft med ChatGPT 3.5.

Måden man gør det på er, at man klikker på en ikon i øverste højre side af websiden med den dialog man gerne vil linke til, som vist herunder, hvor man kommer i en dialog, så man kan kopiere linket. 
[[fil:link_til_chatGPT.png|Link ikon til dialog i chatGPT]] 
'''Link ikon til dialog i chatGPT'''

Selve linket ser ud som følger: https://chat.openai.com/share/90e9607f-bff9-40d1-a68c-9617051e9615.

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive den foreslåede constructor til følgende kode, hvor bolden placeres mindst en halv diameter fra kanten:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Refleksioner over anvendelsen==
Der er selvfølgelig stadig lang vej til man har et færdigt spil, men ideen var også at tage fat i, hvordan man anvender ChatGPT på en ordentlig og redelig måde i et programmeringsprojekt. Dette kan selvfølgelig altid gradbøjes, men hvis man håndterer anvendelsen som vist i eksemplet, så vil man ikke gøre noget der kommer i nærheden af plagiat.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Fil:Link til chatGPT.png

2024-04-30T10:48:20Z

Bar:

Programmering med ChatGPT

2024-04-30T10:47:45Z

Bar: /* Den meget nemmere metode */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i et skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.

==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære at programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

: Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
: Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
: [Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023)<ref>[https://chat.openai.com/chat Indgangen til ChatGPT 3.5]</ref> der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024)<ref>[https://processing.org Hovedsiden for Processing]</ref> og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

Når man opretter kilden i Word, så er det lidt forskelligt hvilke felter der er synlige, alt efter hvilken standard man har aktiv - men ved Harvard-Anglia standarden kan indtastningerne se således ud:

[[fil:citat-ChatGPT.png|Indtastningerne ved kildehenvisning til ChatGPT|600px]] ''Indtastningerne ved kildehenvisning til ChatGPT''

Mere om teknikken i at anvende kildelister kan ses på [https://holstebro-htx.dk/index.php/Word_Kildeliste Holstebro HTX Wiki - Kildelister].

====Den meget nemmere metode====
Tingene udvikler sig hele tiden, og nu kan man faktisk få et link til den dialog man har haft med ChatGPT 3.5.

Måden man gør det på er, at man klikker på en ikon i øverste højre side af websiden med den dialog man gerne vil linke til, som vist herunder, hvor man kommer i en dialog, så man kan kopiere linket. 
[[fil:link_til_chatGPT.png|Link ikon til dialog i chatGPT]] 
'''Link ikon til dialog i chatGPT'''

Selve linket ser ud som følger: [https://chat.openai.com/share/90e9607f-bff9-40d1-a68c-9617051e9615].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive den foreslåede constructor til følgende kode, hvor bolden placeres mindst en halv diameter fra kanten:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Refleksioner over anvendelsen==
Der er selvfølgelig stadig lang vej til man har et færdigt spil, men ideen var også at tage fat i, hvordan man anvender ChatGPT på en ordentlig og redelig måde i et programmeringsprojekt. Dette kan selvfølgelig altid gradbøjes, men hvis man håndterer anvendelsen som vist i eksemplet, så vil man ikke gøre noget der kommer i nærheden af plagiat.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-04-30T10:47:10Z

Bar: /* Den meget nemmere metode */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i et skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.

==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære at programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

: Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
: Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
: [Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023)<ref>[https://chat.openai.com/chat Indgangen til ChatGPT 3.5]</ref> der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024)<ref>[https://processing.org Hovedsiden for Processing]</ref> og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

Når man opretter kilden i Word, så er det lidt forskelligt hvilke felter der er synlige, alt efter hvilken standard man har aktiv - men ved Harvard-Anglia standarden kan indtastningerne se således ud:

[[fil:citat-ChatGPT.png|Indtastningerne ved kildehenvisning til ChatGPT|600px]] ''Indtastningerne ved kildehenvisning til ChatGPT''

Mere om teknikken i at anvende kildelister kan ses på [https://holstebro-htx.dk/index.php/Word_Kildeliste Holstebro HTX Wiki - Kildelister].

====Den meget nemmere metode====
Tingene udvikler sig hele tiden, og nu kan man faktisk få et link til den dialog man har haft med ChatGPT 3.5.

Måden man gør det på er, at man klikker på en ikon i øverste højre side af websiden med den dialog man gerne vil linke til, som vist herunder, hvor man kommer i en dialog, så man kan kopiere linket. 
[[img:link_til_chatGPT.png|Link ikon til dialog i chatGPT]] 
'''Link ikon til dialog i chatGPT'''

Selve linket ser ud som følger: [https://chat.openai.com/share/90e9607f-bff9-40d1-a68c-9617051e9615].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive den foreslåede constructor til følgende kode, hvor bolden placeres mindst en halv diameter fra kanten:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Refleksioner over anvendelsen==
Der er selvfølgelig stadig lang vej til man har et færdigt spil, men ideen var også at tage fat i, hvordan man anvender ChatGPT på en ordentlig og redelig måde i et programmeringsprojekt. Dette kan selvfølgelig altid gradbøjes, men hvis man håndterer anvendelsen som vist i eksemplet, så vil man ikke gøre noget der kommer i nærheden af plagiat.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-04-30T10:43:15Z

Bar: /* Metodeafsnit med omtale af ChatGPT */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i et skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.

==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære at programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

: Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
: Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
: [Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023)<ref>[https://chat.openai.com/chat Indgangen til ChatGPT 3.5]</ref> der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024)<ref>[https://processing.org Hovedsiden for Processing]</ref> og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

Når man opretter kilden i Word, så er det lidt forskelligt hvilke felter der er synlige, alt efter hvilken standard man har aktiv - men ved Harvard-Anglia standarden kan indtastningerne se således ud:

[[fil:citat-ChatGPT.png|Indtastningerne ved kildehenvisning til ChatGPT|600px]] ''Indtastningerne ved kildehenvisning til ChatGPT''

Mere om teknikken i at anvende kildelister kan ses på [https://holstebro-htx.dk/index.php/Word_Kildeliste Holstebro HTX Wiki - Kildelister].

====Den meget nemmere metode====
Tingene udvikler sig hele tiden, og nu kan man faktisk få et link til den dialog man har haft med ChatGPT 3.5.

Måden man gør det på er, at man klikker på en ikon i øverste højre side af websiden med den dialog man gerne vil linke til, som vist herunder, hvor man kommer i en dialog, så man kan kopiere linket. 
[img:link_til_chatGPT.png|Link ikon til dialog i chatGPT] 
'''Link ikon til dialog i chatGPT'''

Selve linket ser ud som følger: [https://chat.openai.com/share/90e9607f-bff9-40d1-a68c-9617051e9615].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive den foreslåede constructor til følgende kode, hvor bolden placeres mindst en halv diameter fra kanten:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Refleksioner over anvendelsen==
Der er selvfølgelig stadig lang vej til man har et færdigt spil, men ideen var også at tage fat i, hvordan man anvender ChatGPT på en ordentlig og redelig måde i et programmeringsprojekt. Dette kan selvfølgelig altid gradbøjes, men hvis man håndterer anvendelsen som vist i eksemplet, så vil man ikke gøre noget der kommer i nærheden af plagiat.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Komponent

2024-04-09T18:07:34Z

Bar:

Komponentliste https://www.holstebro-htx.dk/el/komp.php
==Byggestenene==
Elektronik er opbygget af forskellige komponenter, hvor man typisk skelner mellem [[analog]]e og [[digital]]e komponenter.

Mange komponenter kan anvendes både i analoge og digitale opstillinger, men de har lidt forskellig funktion, alt efter hvordan de anvendes. En [[transistor]] kan anvendes som en kontakt, altså en digital komponent, og den kan anvendes som analog forstærker. I begge tilfælde skal der også modstande med i kredsløbet, altså igen kan modstanden indgå i begge typer kredsløb.

==Lager==
På Holstebro HTX forsøger vi at have et fornuftigt lager af de gængse komponenter der anvendes i undervisningen. En del af disse komponenter er registreret i vores lagersystem<ref>https://www.holstebro-htx.dk/el/komp.php vores lagersystem på Holstebro HTX</ref>, hvor man kan finde datablad for komponenten, i nogle tilfælde prisen (eller en standard pris på 3,00), og hvor man kan finde komponenten i lokalet.

==Moduler==
Ud over komponenter har vi også en del små moduler, specielt til [[Arduino]] på lager - de ligger i en separat liste under Moduler på https://www.holstebro-htx.dk/el/modul.php

==Referencer==
<references />

{{analog}}

[[Kategori:Værkstedet]]

Programmering med ChatGPT

2024-03-20T10:12:38Z

Bar: /* Metodeafsnit med omtale af ChatGPT */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i et skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.

==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære at programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

: Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
: Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
: [Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023)<ref>[https://chat.openai.com/chat Indgangen til ChatGPT 3.5]</ref> der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024)<ref>[https://processing.org Hovedsiden for Processing]</ref> og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

Når man opretter kilden i Word, så er det lidt forskelligt hvilke felter der er synlige, alt efter hvilken standard man har aktiv - men ved Harvard-Anglia standarden kan indtastningerne se således ud:

[[fil:citat-ChatGPT.png|Indtastningerne ved kildehenvisning til ChatGPT|600px]] ''Indtastningerne ved kildehenvisning til ChatGPT''

Mere om teknikken i at anvende kildelister kan ses på [https://holstebro-htx.dk/index.php/Word_Kildeliste Holstebro HTX Wiki - Kildelister].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive den foreslåede constructor til følgende kode, hvor bolden placeres mindst en halv diameter fra kanten:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Refleksioner over anvendelsen==
Der er selvfølgelig stadig lang vej til man har et færdigt spil, men ideen var også at tage fat i, hvordan man anvender ChatGPT på en ordentlig og redelig måde i et programmeringsprojekt. Dette kan selvfølgelig altid gradbøjes, men hvis man håndterer anvendelsen som vist i eksemplet, så vil man ikke gøre noget der kommer i nærheden af plagiat.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-03-20T10:08:13Z

Bar: /* Eksempel på dokumentation */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i et skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.

==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære at programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

: Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
: Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
: [Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023)<ref>[https://chat.openai.com/chat Indgangen til ChatGPT 3.5]</ref> der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024)<ref>[https://processing.org Hovedsiden for Processing]</ref> og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

Når man opretter kilden i Word, så er det lidt forskelligt hvilke felter der er synlige, alt efter hvilken standard man har aktiv - men ved Harvard standarden kan indtastningerne se således ud:

[[fil:citat-ChatGPT.png|Indtastningerne ved kildehenvisning til ChatGPT|600px]] ''Indtastningerne ved kildehenvisning til ChatGPT''

Mere om teknikken i at anvende kildelister kan ses på [https://holstebro-htx.dk/index.php/Word_Kildeliste Holstebro HTX Wiki - Kildelister].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive den foreslåede constructor til følgende kode, hvor bolden placeres mindst en halv diameter fra kanten:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Refleksioner over anvendelsen==
Der er selvfølgelig stadig lang vej til man har et færdigt spil, men ideen var også at tage fat i, hvordan man anvender ChatGPT på en ordentlig og redelig måde i et programmeringsprojekt. Dette kan selvfølgelig altid gradbøjes, men hvis man håndterer anvendelsen som vist i eksemplet, så vil man ikke gøre noget der kommer i nærheden af plagiat.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-03-20T10:06:26Z

Bar: /* Hvad må man ikke i en skoleprojekt */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i et skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.

==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære at programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
[Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023)<ref>[https://chat.openai.com/chat Indgangen til ChatGPT 3.5]</ref> der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024)<ref>[https://processing.org Hovedsiden for Processing]</ref> og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

Når man opretter kilden i Word, så er det lidt forskelligt hvilke felter der er synlige, alt efter hvilken standard man har aktiv - men ved Harvard standarden kan indtastningerne se således ud:

[[fil:citat-ChatGPT.png|Indtastningerne ved kildehenvisning til ChatGPT|600px]] ''Indtastningerne ved kildehenvisning til ChatGPT''

Mere om teknikken i at anvende kildelister kan ses på [https://holstebro-htx.dk/index.php/Word_Kildeliste Holstebro HTX Wiki - Kildelister].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive den foreslåede constructor til følgende kode, hvor bolden placeres mindst en halv diameter fra kanten:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Refleksioner over anvendelsen==
Der er selvfølgelig stadig lang vej til man har et færdigt spil, men ideen var også at tage fat i, hvordan man anvender ChatGPT på en ordentlig og redelig måde i et programmeringsprojekt. Dette kan selvfølgelig altid gradbøjes, men hvis man håndterer anvendelsen som vist i eksemplet, så vil man ikke gøre noget der kommer i nærheden af plagiat.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-03-18T20:27:48Z

Bar: /* Metodeafsnit med omtale af ChatGPT */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i en skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.
==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære at programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
[Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023)<ref>[https://chat.openai.com/chat Indgangen til ChatGPT 3.5]</ref> der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024)<ref>[https://processing.org Hovedsiden for Processing]</ref> og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

Når man opretter kilden i Word, så er det lidt forskelligt hvilke felter der er synlige, alt efter hvilken standard man har aktiv - men ved Harvard standarden kan indtastningerne se således ud:

[[fil:citat-ChatGPT.png|Indtastningerne ved kildehenvisning til ChatGPT|600px]] ''Indtastningerne ved kildehenvisning til ChatGPT''

Mere om teknikken i at anvende kildelister kan ses på [https://holstebro-htx.dk/index.php/Word_Kildeliste Holstebro HTX Wiki - Kildelister].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive den foreslåede constructor til følgende kode, hvor bolden placeres mindst en halv diameter fra kanten:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Refleksioner over anvendelsen==
Der er selvfølgelig stadig lang vej til man har et færdigt spil, men ideen var også at tage fat i, hvordan man anvender ChatGPT på en ordentlig og redelig måde i et programmeringsprojekt. Dette kan selvfølgelig altid gradbøjes, men hvis man håndterer anvendelsen som vist i eksemplet, så vil man ikke gøre noget der kommer i nærheden af plagiat.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-03-18T20:27:09Z

Bar: /* Metodeafsnit med omtale af ChatGPT */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i en skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.
==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære at programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
[Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023)<ref>[https://chat.openai.com/chat Indgangen til ChatGPT 3.5]</ref> der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024)<ref>[https://processing.org Hovedsiden for Processing]</ref> og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

Når man opretter kilden i Word, så er det lidt forskelligt hvilke felter der er synlige, alt efter hvilken standard man har aktiv - men ved Harvard standarden kan indtastningerne se således ud:

[[fil:citat-ChatGPT.png|Indtastningerne ved kildehenvisning til ChatGPT]] ''Indtastningerne ved kildehenvisning til ChatGPT''

Mere om teknikken i at anvende kildelister kan ses på [https://holstebro-htx.dk/index.php/Word_Kildeliste Holstebro HTX Wiki - Kildelister].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive den foreslåede constructor til følgende kode, hvor bolden placeres mindst en halv diameter fra kanten:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Refleksioner over anvendelsen==
Der er selvfølgelig stadig lang vej til man har et færdigt spil, men ideen var også at tage fat i, hvordan man anvender ChatGPT på en ordentlig og redelig måde i et programmeringsprojekt. Dette kan selvfølgelig altid gradbøjes, men hvis man håndterer anvendelsen som vist i eksemplet, så vil man ikke gøre noget der kommer i nærheden af plagiat.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Fil:Citat-ChatGPT.png

2024-03-18T20:25:35Z

Bar:

Programmering med ChatGPT

2024-03-18T20:25:07Z

Bar: /* Metodeafsnit med omtale af ChatGPT */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i en skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.
==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære at programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
[Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023)<ref>[https://chat.openai.com/chat Indgangen til ChatGPT 3.5]</ref> der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024)<ref>[https://processing.org Hovedsiden for Processing]</ref> og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

Når man opretter kilden i Word, så er det lidt forskelligt hvilke felter der er synlige, alt efter hvilken standard man har aktiv - men ved Harvard standarden kan indtastningerne se således ud:

[[fil:citat-ChatGPT.png|Indtastningerne ved kildehenvisning til ChatGPT]] ''Indtastningerne ved kildehenvisning til ChatGPT''

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive den foreslåede constructor til følgende kode, hvor bolden placeres mindst en halv diameter fra kanten:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Refleksioner over anvendelsen==
Der er selvfølgelig stadig lang vej til man har et færdigt spil, men ideen var også at tage fat i, hvordan man anvender ChatGPT på en ordentlig og redelig måde i et programmeringsprojekt. Dette kan selvfølgelig altid gradbøjes, men hvis man håndterer anvendelsen som vist i eksemplet, så vil man ikke gøre noget der kommer i nærheden af plagiat.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-03-18T13:02:44Z

Bar: /* Hvad er tilladt med ChatGPT */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i en skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.
==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære at programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
[Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023)<ref>[https://chat.openai.com/chat Indgangen til ChatGPT 3.5]</ref> der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024)<ref>[https://processing.org Hovedsiden for Processing]</ref> og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive den foreslåede constructor til følgende kode, hvor bolden placeres mindst en halv diameter fra kanten:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Refleksioner over anvendelsen==
Der er selvfølgelig stadig lang vej til man har et færdigt spil, men ideen var også at tage fat i, hvordan man anvender ChatGPT på en ordentlig og redelig måde i et programmeringsprojekt. Dette kan selvfølgelig altid gradbøjes, men hvis man håndterer anvendelsen som vist i eksemplet, så vil man ikke gøre noget der kommer i nærheden af plagiat.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-03-17T08:35:49Z

Bar: /* Refleksioner over anvendelsen */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i en skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.
==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære et programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
[Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023)<ref>[https://chat.openai.com/chat Indgangen til ChatGPT 3.5]</ref> der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024)<ref>[https://processing.org Hovedsiden for Processing]</ref> og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive den foreslåede constructor til følgende kode, hvor bolden placeres mindst en halv diameter fra kanten:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Refleksioner over anvendelsen==
Der er selvfølgelig stadig lang vej til man har et færdigt spil, men ideen var også at tage fat i, hvordan man anvender ChatGPT på en ordentlig og redelig måde i et programmeringsprojekt. Dette kan selvfølgelig altid gradbøjes, men hvis man håndterer anvendelsen som vist i eksemplet, så vil man ikke gøre noget der kommer i nærheden af plagiat.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-03-17T08:34:57Z

Bar: /* Referencer */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i en skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.
==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære et programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
[Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023)<ref>[https://chat.openai.com/chat Indgangen til ChatGPT 3.5]</ref> der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024)<ref>[https://processing.org Hovedsiden for Processing]</ref> og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive den foreslåede constructor til følgende kode, hvor bolden placeres mindst en halv diameter fra kanten:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Refleksioner over anvendelsen==
Der er selvfølgelig stadig lang vej til man har et færdigt spil, men ideen var også at tage fat i, hvordan man anvender ChatGPT på en ordentlig redelig måde i et programmeringsprojekt. Dette kan selvfølgelig altid gradbøjes, men hvis man håndterer anvendelsen som vist i eksemplet, så vil man ikke gøre noget der kommer i nærheden af plagiat.
==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-03-17T08:27:38Z

Bar: /* Dokumentation af koden udviklet af ChatGPT */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i en skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.
==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære et programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
[Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023)<ref>[https://chat.openai.com/chat Indgangen til ChatGPT 3.5]</ref> der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024)<ref>[https://processing.org Hovedsiden for Processing]</ref> og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive den foreslåede constructor til følgende kode, hvor bolden placeres mindst en halv diameter fra kanten:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-03-17T08:22:43Z

Bar: /* Metodeafsnit med omtale af ChatGPT */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i en skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.
==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære et programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
[Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023)<ref>[https://chat.openai.com/chat Indgangen til ChatGPT 3.5]</ref> der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024)<ref>[https://processing.org Hovedsiden for Processing]</ref> og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive de constructor til følgende kode:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-03-17T08:17:28Z

Bar: /* ChatGPT som kilde til kode */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i en skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.
==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære et programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
[Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing, der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023) der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024) og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive de constructor til følgende kode:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-03-17T08:16:49Z

Bar: /* ChatGPT som kilde til kode */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i en skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.
==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære et programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
[Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Det følgende er skrevet med udgangspunkt i det der er beskrevet på viden.ai<ref>[https://viden.ai/korrekt-kildehenvisning-af-chatgpt/ Korrekt kildehenvisning af ChatGPT]</ref>. hvor der angives hvordan man kildehenviser, men også lidt om hvordan man håndterer det i tekst - i korte træk, lav et metodeafsnit, beskriv hvad man gør og vær meget redelig, ved at man angiver hvad man har fået af ChatGPT ved at lægge det ved som et bilag.

Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing- der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023) der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024) og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive de constructor til følgende kode:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.

==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-03-17T08:03:25Z

Bar: /* Problemet med ChatGPT */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i en skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.
==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære et programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver har et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.

==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
[Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing- der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023) der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024) og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive de constructor til følgende kode:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.
==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-03-17T07:59:38Z

Bar:

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man skal have forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i en skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.
==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære et programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver her et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.
==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
[Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing- der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023) der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024) og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive de constructor til følgende kode:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.
==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-03-16T17:14:21Z

Bar: /* Referencer */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man har forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i en skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.
==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære et programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver her et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.
==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
[Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing- der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023) der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024) og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive de constructor til følgende kode:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.
==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Skabelon:Programmering

2024-03-16T17:13:53Z

Bar:

{| class="oversigt"
|-
<th colspan="2"> [[:Kategori:Programmering|Programmering]]</th>
|-
|id="emne"| [[:Kategori:Programmeringsbegreber|Programmeringsbegreber]] || [[Initialisering]] - [[Sekvens]] - [[Algoritme]] - [[Hexadecimal]] - [[Det Binære Talsystem]] - [[HEX-fil]] - [[ASCII]] - [[Interrupt]] - [[Events]] - [[Styresystem]] - [[Autocomplete]] - [[Selvstudie Programmering]] - [[Hour Of Code]] - [[Stepwise Improvement]] - [[Syntaks]] - [[Prog-links]] - [[:Kategori:Microcontroller|Microcontroller]] - [[Programmering_med_ChatGPT|ChatGPT]]
|-
|id="emne"| [[:Kategori:Grundlæggende C|Grundlæggende C]] || [[C float]] - [[C double]] - [[C-løkker]] - [[Datatyper]] - [[Konstanter]] - [[Regnearter]] - [[Funktioner]] - [[Return]] - [[Returværdi]] - [[Rekursion]] - [[Semikolon]]
|-
|id="emne"| [[:Kategori:Variabel-typer|Variabel Typer]] || [[Datatyper#boolean|boolean]] - [[Datatyper#byte|byte]] - [[Datatyper#int|int]] - [[Datatyper#unsigned int|unsigned int]] - [[Datatyper#word|word]] - [[Datatyper#long|long]] - [[Datatyper#unsigned long|unsigned long]] - [[Datatyper#short|short]] - [[Datatyper#float|float]] - [[Datatyper#double|double]] - [[Datatyper#char|char]] - [[Datatyper#unsigned char|unsigned char]] - [[Datatyper#string|string - char array]] - [[Datatyper#String_2|String - object]] - [[Array]] - [[2-dimensionelt Array]] - [[Datatyper#void|void]]
|-
|id="emne"| [[:Kategori:Program-klassikere|Program-klassikere]] || [[Polling]] - [[State-machine]] - [[Trykknap]] - [[Forkant]] - [[Bagkant]] - [[Prel]]
|-
|id="emne"| [[:Kategori:Arduino|Arduino]] || [[:Kategori:Arduino til Programmering|Arduino til Programmering]] - [[:Kategori:C til Arduino|C til Arduino]] - [[Programmering Shield]] - [[Arduino PC-software]] - [[Arduino Udviklingsmiljø]] - [[Arduino Pin Library]] - [[:Kategori:Funktion|Funktion]] - [[:Kategori:Arduino Seriel|Arduino Seriel]] - [[:Kategori:Arduino String|Arduino String]] - [[Arduino String Split]] - [[Arduino StateChangeDetection]] - [[setup()]] - [[loop()]] - [[Compilerdirektiver]] - [[Asynkron kommunikation]] - [[millis()]] - [[micros()]] - [[:Kategori:Scratch for Arduino|Scratch for Arduino]] - [[Send fra Arduino til Excel]] - [[]] - [[]]
|-
|id="emne"| [[:Kategori:Processing|Processing]] || [[:Kategori:Grafik i Processing‎|Grafik i Processing‎]] - [[:Kategori:Keyboard i Processing|Keyboard i Processing]] - [[:Kategori:Mus i Processing‎|Mus i Processing‎]] - [[:Kategori:Tid i Processing‎|Tid i Processing‎]] - [[Draw()]] - [[Setup()]] - [[Tal Input til Processing]] - [[Syntaksfarvning]] - [[Kommunikation fra Arduino til Processing]] - [[Kommunikation fra Processing til Arduino]]
|-
|id="emne"| [[:Kategori:javascript|javaScript]] || [[:kategori:Javascript input‎|Javascript input‎]] - [[:kategori:Javascript output‎|Javascript output‎]] - [[:kategori:Javascript strukturer‎|Javascript strukturer‎]] - [[:kategori:Javascript syntaks‎|Javascript syntaks‎]] - [[Tid i javaScript]] - [[Objekt‎]] - [[AJAX]]
|-
|id="emne"| [[:Kategori:Server|Serverprogrammering]] || [[PHP]] - [[MySQL]] - [[Task Scheduler]] - [[WeMOS]]
|-
|id="emne"| [[:Kategori:PIC|PIC]] || [[JAL]] - [[]]
|-
|id="emne"| [[:Kategori:Scratch for Arduino|Scratch for Arduino]] || [[S4A Installation]] - [[S4A programmering]] - [[S4A undervisningsforløb]] - [[S4A begrænsninger]]
|-
|id="emne"| [[:Kategori:Dokumentationsformer|Program Dokumentation]] || [[Algoritme]] - [[Flowchart]] - [[Pseudokode]] - [[Datastruktur]] - [[Dataabstraktion]] - [[Pulsplaner]] - [[Program-kommentar]] - [[Teori]] - [[Test]] - [[UML]]
|}

Programmering med ChatGPT

2024-03-16T17:01:00Z

Bar: /* Referencer */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man har forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i en skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.
==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære et programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver her et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.
==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
[Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing- der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023) der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024) og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive de constructor til følgende kode:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

====Oprettelse af ny bold====
I den oprindelige kode undersøges om der er klikket på en bold, ved at alle bolde løbes igennem i mousePressed() funktionen, og med metoden contains undersøges om der er klikket på en bold. Denne måde at undersøge alle bolde på beholdes.

Som omtalt er det ikke den smarteste måde til at dele bolden op i to, der anvendes. Som det ses i koden herunder, så appendes der to nye bolde på med den oprindelige bolds x- og y-position på samt tilfældige x- og y-hastigheder. Disse to bolde lægges i slutningen af arrayet. Derefter anvendes shorten<ref>[https://processing.org/reference/shorten_.html Processings shorten metode til arrays]</ref> til at fjerne et element, men da det element der fjernes er det sidste element i arrayet, så fjernes der bare den sidst oprettede bold.

Hvis man var tilfreds med den opførsel, så kunne man blot fjerne kodelinjen med den anden append og kodelinjen med shorten. Så ville man have samme funktion.
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) append(balls, new Ball(balls[i].x, balls[i].y, random(-5, 5), random(-5, 5)));
balls = (Ball[]) shorten(balls);
break;
}
</syntaxhighlight>

Den nye bold der oprettes får bare en tilfældig retning, og den oprindelige bold fortsætter bare i den retning den var på vej i. Det er ikke den opførsel der ønskes i spillet. Der ønskes i stedet at det ser ud som om bolden "splittes op" i 2 bolde, og den opførsel laves ved at lade den oprindelige bold ændre 30 grader til den ene side, og den nye bold får 30 grader til den anden side.

For at gøre dette, så oprettes der en metode multiply() i klassen Ball. Denne metode returnerer en ny bold af typen Ball, så nu kan koden i museklikket skrives som følger:
<syntaxhighlight lang="C">
if (balls[i].contains(mouseX, mouseY)) {
balls = (Ball[]) append(balls, balls[i].multiply());
break;
}
</syntaxhighlight>
Som det kan ses, så appendes der en ny bold ind i balls-arrayet, ud fra metoden multiply().

Metoden multiply() oprettes inde i klassen med følgende kode:
<syntaxhighlight lang="C">
Ball multiply() {
xspeed *= xdirection;
yspeed *= ydirection;
xdirection = 1;
ydirection = 1;
float speed = dist(0, 0, xspeed, yspeed);
float angle = acos(xspeed / speed);
if (yspeed < 0) angle = 0.0 - angle;
speed *= 1.5;
xspeed = speed * cos(angle + PI / 6);
yspeed = speed * sin(angle + PI / 6);
Ball b = new Ball(x, y, speed * cos(angle - PI / 6), speed * sin(angle - PI / 6));
return b;
}
</syntaxhighlight>
Først regnes retningen over i xspeed og yspeed, så de kan være både positive og negative. På den måde indeholder de to variabler retningen.

Dernæst omregnes x- og y-hastigheden til en samlet hastighed speed og en vinkel angle, som kan være mellem +PI og -PI (+/- 180 grader).

Begge bolde skal bevæge sig hurtigere efter de er delt, så spillet gradvist bliver sværere, derfor ganges hastigheden med 1,5.

Den oprindelige bold får nu en ny retning, ved at udregne x- og y-hastigheden ud fra den nye hastighed og vinklen plus 30 grader.

Til sidst oprettes en ny bold med samme position som den oprindelige og en x- og y-hastighed udregnet fra den oprindelige bolds hastighed og vinklen minus 30 grader. Denne bold returneres fra metoden.
==Referencer==
<syntaxhighlight lang="C">
</syntaxhighlight>
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-03-16T16:20:26Z

Bar: /* Metodeafsnit med omtale af ChatGPT */

Det er ikke så svært at få ChatGPT<ref>[https://chat.openai.com/auth/login ChatGPT Login] - Indgangen til ChatGPT</ref> til at lave kode, der skal man blot beskrive hvad man gerne vil have programmet til at gøre, og så kopiere den kode, der kommer ud af det - det giver tit ret gode resultater.

Problemet med at anvende ChatGPT i forbindelse med skoleprojekter er, at man har forståelsen med i det, og at man ikke kan blive anklaget for plagiat.

==Hvad må man ikke i en skoleprojekt==
*Man må ikke kopiere kode, som man ikke selv har skrevet, til et programmeringsprodukt uden at man angiver en kilde. Det er uanset hvor koden stammer fra, også selvom man har brugt ChatGPT til at "udvikle" koden.
*Man må ikke aflevere et produkt hvor de primære dele af koden er kopieret, heller ikke selvom man kildehenviser.
*Man må ikke få ChatGPT til at dokumentere sin kode, ved at man kopierer ChatGPT's beskrivelse ind i sin dokumentation af koden.

De beskrevne eksempler er at betragte som plagiat, og vil blive håndteret efter skolens ordensregler, hvilket i værste fald kan ende med at et fag annulleres eller man bliver bortvist fra uddannelsen.
==Hvad er tilladt med ChatGPT==
På samme måde som man må anvende kilder fra internettet, så må man i programmerings-faget i gymnasiet anvende ChatGPT i udviklingen af kode til et programmeringsprodukt. Dette er blevet tilladt via en revidering af vejledningen til faget<ref>[https://www.uvm.dk/-/media/filer/uvm/udd/gym/pdf23/aug/vejledninger/valgfag/230807-programmering-c--valgfag.pdf Vejledning] til Valgfaget Programmering C</ref>.

I vejledningen står der som følger:

: ''"brug af internettet er tilladt som fagligt hjælpemiddel ved de mundtlige prøver, inkluderer de tilladte hjælpemidler anvendelsen af chatbots og lignende på en måde, som afspejler, hvordan man arbejder i den daglige undervisning. Dette kunne fx være brug af ChatGPT til at debugge kode."''

Det skal altså afspejle den normale brug, som man også har ved at bruge internettet. Som angivet under hvad man ikke må, så er den normale brug, at man anvender information til at lære et programmere, men at man ikke tager så meget af sit produkt fra nettet, så man ikke har en forståelse af hvordan produktet er sammensat.

Videre i vejledningen står der:

: ''"I forhold til denne type hjælpemidler er det vigtigt at være opmærksom på, at den tilladte anvendelse er betinget af, at hjælpemidlerne kun benyttes i et omfang, hvor prøvebesvarelsen er selvstændig og udelukkende elevens egen."''

Igen understreges at det der afleveres skal være elevens selvstændigt udviklede produkt og dokumentation, hvor man på normal vis anvender internettet som et værktøj til at bibringe forståelse.

==Problemet med ChatGPT==
Ligesom man ikke kan kilde-henvise til "google", for at angive at man har fundet informationer på nettet, så kan man heller ikke kildehenvise til ChatGPT direkte som en kilde.

Når man finder informationer med google', så skal man angive hvor på nettet man har fundet dem med så præcis en kildehenvisning, at man kan se den information der er blevet anvendt.

Denne type henvisning kan man ikke lave i forhold til ChatGPT, da sprogmodellen der ligger bag ChatGPT konstant udvikler sig, samt at de svar sprogmodellen giver her et randomiseret element indbygget, som er med til at give bedre svar<ref>[https://www.it-vest.dk/arrangementer/sig-webinar-14-marts-2024-kunstig-intelligens-og-chatgpt-hvordan-virker-det-og-skal-vi-bare-opgive-undervisning-og-eksamen Webinar om kunstig intelligens]</ref>.

Her er man altså nødt til at tage andre metoder i brug, for at kunne dokumentere at man har udviklet sit produkt ordentligt og redeligt.
==Kildehenvisninger i dokumentation==
Der kan være forskellige standarder for hvordan man kildehenviser i forskellige uddannelser, dette er skrevet med udgangspunkt i at man anvender Word bibliografi-værktøj og her vist med en Harvard-lignende standard<ref>[https://holstebro-htx.dk/index.php/Word_Kildeliste Kildelister] anvendt i Microsoft Word</ref>.

===Normal Internet-kilde til kode===
I dette eksempel er der angivet hvordan man ville dokumentere at man har anvendt kode fra et bibliotek til noget hardware på en [[Arduino]]. I det tænkte eksempel er det en 4 kanals AD-konverter<ref>[https://arduinotech.dk/shop/ads1115-module-4-channel-16-bit-i2c-adc-with-pro-gain-amplifier 4 kanals AD-konverter] fra ArduinoTech</ref>, der er købt som modul.

For at kunne anvende modulet i koden skal der kommunikeres med modulet på en måde, som er angivet i beskrivelsen af modulet - det er dog ikke nødvendigt at sætte sig ind i den grundlæggende kommunikation, hvis man blot ønsker at få værdier ind i sin software. Som en dokumentation for hvordan man anvender biblioteket kan man skrive følgende:

====Eksempel på dokumentation====
Til at hente værdierne fra den 4 kanals AD-konverter anvendes et bibliotek fundet på GitHub (Singh, 2018) som kan indlæse de analoge spændinger.
Til at sætte AD-konverteren rigtigt op, til at kunne læse 4 spændinger, så anvendes eksemplet ”ADS1115_SingleEnded.ino” og i setup skrives følgende kode:
<syntaxhighlight lang="c">
ads.getAddr_ADS1115(ADS1115_DEFAULT_ADDRESS); // 0x48, 1001 000 (ADDR = GND)
ads.setGain(GAIN_TWO); // 2x gain +/- 2.048V 1 bit = 0.0625mV (default)
ads.setMode(MODE_CONTIN); // Continuous conversion mode
ads.setRate(RATE_128); // 128SPS (default)
ads.setOSMode(OSMODE_SINGLE); // Set to start a single-conversion
ads.begin();
</syntaxhighlight>
I [[loop()]] testes i første omgang, om det kan lade sig gøre at læse de 4 kanaler. Dette gøres ved at afvikle følgende testkode:
<syntaxhighlight lang="c">
address = ads.ads_i2cAddress;
Wire.beginTransmission(address);
error = Wire.endTransmission();
if (error == 0)
{
int16_t adc0, adc1, adc2, adc3;

adc0 = ads.Measure_SingleEnded(0);
Serial.print("Digital Value of Analog Input at Channel 1: ");
Serial.println(adc0);
adc1 = ads.Measure_SingleEnded(1);
Serial.print("Digital Value of Analog Input at Channel 2: ");
Serial.println(adc1);
adc2 = ads.Measure_SingleEnded(2);
Serial.print("Digital Value of Analog Input at Channel 3: ");
Serial.println(adc2);
adc3 = ads.Measure_SingleEnded(3);
Serial.print("Digital Value of Analog Input at Channel 4: ");
Serial.println(adc3);
}
</syntaxhighlight>
Denne test giver det ønskede resultat.

Ud fra denne beskrivelse viser man, at man tager andres kode, og anvender ind i sit eget projekt, og man angiver præcist i sin beskrivelse hvad man har taget fra andres kode.

I kildelisten vil kilden optræde på følgende måde:

Singh, Y., 2018. Arduino Library ADS1115 16 bit 4 channel ADC. [Online] 
Available at: https://github.com/ncdcommunity/Arduino_Library_ADS1115_16Bit_4Channel_ADC 
[Senest hentet eller vist den 15 marts 2024].

===ChatGPT som kilde til kode===
Hvis man forstår at prompte fornuftigt, så er ChatGPT faktisk ret god til at foreslå kode, der kan anvendes, men ligesom det er plagiat hvis man kopierer fra nettet, så er det plagiat, hvis man lader ChatGPT skrive store dele af ens program for sig.

Som det er formuleret i vejledningen til både programmering C og B, så kan man anvende ChatGPT til hjælp i fejlfinding af kode. For at kunne kildehenvise korrekt til hjælp med fejlfinding, så skal man angive hvad man har promptet til ChatGPT og hvad den har svaret - det kan placeres i bilag.

En anden ting, som også er OK at få hjælp med er, at komme i gang med programmet - det er denne problematik der her gives et eksempel på. I eksemplet beskrives hvad man skal skrive i sin dokumentation, når man har anvendt denne hjælp, og der er forslag til hvordan man kommer videre i projektet.

Konkret er det starten på udviklingen af et lille spil med bolde i et vindue, udviklet i Processing- der tages udgangspunkt i.

====Metodeafsnit med omtale af ChatGPT====
Når man anvender CharGPT, så skal man dokumentere hvordan man har gjort det, og hvilke overvejelser der ligger bag det. Det betegnes i rapportskrivning som et metodeafsnit. Det kunne i dette eksempel lyde:

For at få en fornuftig start på programkoden er der brugt ChatGPT til at få rammerne på koden etableret, og til at få et system, så der kan optræde flere bolde i programvinduet. Det er ChatGPT 3.5 (OpenAI, 2023) der er anvendt til denne hjælp. Til programstarten blev der promptet efter at få et programvindue på 800x600 hvor en bold bevæger sig rundt. Den foreslåede kode blev kopieret ind i processings IDE (Processing, 2024) og testet – den opførte sig som forventet.

Derefter blev der promptet efter at få den bold der bevægede sig til at dele sig op i to, når man klikker på den med musen. Dette resulterede i en væsentligt anderledes kode, som igen blev kopieret ind i processing og testet, og igen med et acceptabelt resultat. Dialogen med ChatGPT (OpenAI, 2023) og herunder de to koder, kan ses i bilag 1.

Herefter er resten af koden udviklet på traditionel vis, hvor første trin var at dokumentere princippet i den foreslåede kode, specielt den Ball klasse der blev introduceret for at kunne arbejde med flere bolde i vinduet.

Det nævnte bilag 1 [[media:ChatGPT-dialog-1.pdf|kan ses i denne PDF]].

====Dokumentation af koden udviklet af ChatGPT====
Da der skulle kunne dannes nye bolde så oprettes der en klasse, som ChatGPT skriver det i dialogen i Bilag 1:

: ''"Dette kodeeksempel opretter en klasse kaldet Ball, som repræsenterer boldobjekterne. Når musen klikkes, kontrolleres det, om musens position er inden for en bold. Hvis det er tilfældet, oprettes to nye boldobjekter, der bevæger sig i forskellige retninger, og den originale bold fjernes fra arrayet."''

Ved at teste koden kan man se at det ikke er det helt rigtige den formulerer - der oprettes godt nok to nye bold-objekter, men det er ikke den oprindelige bold der fjernes, det er den ene af de ny-oprettede bolde. Det kan ses ved at de to bolde kommer i samme position, og den ene fortsætter i samme retning (den oprindelige), mens den ny-oprettede går i en tilfældig retning. Dette rettes til senere i dokumentationen under "oprettelse af ny bold".

For at have en god struktur i koden, så placeres klassen Ball i en fil for sig kaldet Ball. Denne fil starter med at definere koden som en klasse med linjen:
<syntaxhighlight lang="C">
class Ball {
</syntaxhighlight>

Dernæst defineres klassens egenskaber, der er boldens position og hastighed samt en fast diameter. Ud over det er der en x- og y-retning defineret. Den anvendes til at sige om bolden bevæger sig i en positiv eller negativ retning, så de skifter mellem +1 og -1, når kanterne rammes.
<syntaxhighlight lang="C">
float x, y;
float xspeed, yspeed;
int diameter = 30;
int xdirection = 1;
int ydirection = 1;
</syntaxhighlight>

Der defineres to forskellige constructors til bolden. Den første anvendes til at danne den første bold med, hvor position og hastighed sættes tilfældigt.

Her forudses et problem at der kan komme et randfænomen, hvis bolden dannes, så den ligger med noget uden for skærmen. Da det er tilfældigt; så er det sjældent problemet opstår. For at fremprovokere det oftere er det testet med en diameter på 200, hvor det kunne ses at bolden bliver "hængende" i kanten.
<syntaxhighlight lang="C">
Ball() {
x = random(width);
y = random(height);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>
Dette rettes ved at omskrive de constructor til følgende kode:
<syntaxhighlight lang="C">
Ball() {
x = random(diameter / 2, width - diameter / 2);
y = random(diameter / 2, height - diameter / 2);
xspeed = random(0.5, 2);
yspeed = random(0.5, 2);
}
</syntaxhighlight>

Den anden constructor tager fire parametre, der er positionen og hastigheden. Denne constructor anvendes, når der skal dannes nye bolde, hvor koden netop skal starte den nye bold i den oprindelige bolds position, og med en ny retning.
<syntaxhighlight lang="C">
Ball(float x, float y, float xspeed, float yspeed) {
this.x = x;
this.y = y;
this.xspeed = xspeed;
this.yspeed = yspeed;
}
</syntaxhighlight>

Ud over disse standard ting til oprettelsen af objekter, så er der 3 metoder i klassen. Den første er en move() metode:
<syntaxhighlight lang="C">
void move() {
x = x + (xspeed * xdirection);
y = y + (yspeed * ydirection);

if ((x + diameter/2 >= width) || (x - diameter/2 <= 0)) {
xdirection *= -1;
}
if ((y + diameter/2 >= height) || (y - diameter/2 <= 0)) {
ydirection *= -1;
}
}
</syntaxhighlight>
Måden metoden virker på er at den lægger hastigheden til boldens position (både x og y), og hvis boldens position (både i x og y) er kommet uden for rammen, så ændres retningen for enten x eller y.

For at kunne vise bolden er der en display() metode:
<syntaxhighlight lang="C">
void display() {
ellipse(x, y, diameter, diameter);
}
</syntaxhighlight>

Den sidste metode hedder contains(), og den tager en position som parameter til metoden. Der undersøges så om den position ligger inden for bolden ved at se om afstanden mellem boldens center og den testede position er mindre end den halve diameter. Hvis den er inden for bolden, så returneres true, ellers returneres false:
<syntaxhighlight lang="C">
boolean contains(float x, float y) {
float d = dist(x, y, this.x, this.y);
if (d < diameter/2) {
return true;
} else {
return false;
}
}
</syntaxhighlight>

==Referencer==
<references />

{{Programmering}}

[[Kategori:Programmering teknik]]

Programmering med ChatGPT

2024-03-16T14:33:54Z

Bar: /* Metodeafsnit med omtale af ChatGPT */

Fil:ChatGPT-dialog-1.pdf

2024-03-16T14:33:14Z

Bar:

Programmering med ChatGPT

2024-03-16T14:32:01Z

Bar: /* Referencer */

Programmering med ChatGPT

2024-03-15T12:08:03Z

Bar: /* Normal Internet-kilde til kode */

Programmering med ChatGPT

2024-03-15T12:06:53Z

Bar: /* Normal Internet-kilde til kode */

Programmering med ChatGPT

2024-03-15T12:04:34Z

Bar: /* Referencer */

Programmering med ChatGPT

2024-03-15T11:19:31Z

Bar: /* Hvad er tilladt med ChatGPT */