PB200 Weatherstation Weten is het halve werk Bastiaan Crooijmans, Rogier Kloppenburg en Miguel Agterberg

1

PB200 Weatherstation Weten is het halve werk

Bastiaan Crooijmans 12057215

Rogier Kloppenburg 12060828 Miguel Agterberg 12109886

14 maart 2014

2

Inhoudsopgave

Voorwoord Verklarende woordenlijst Inleiding Het Ontwerp

Opbouw Verbinding AVR­CAN Keuze Computer/Microcontroller

Opzet AVR­CAN Module

Opbouw Tests Conclusie

Raspberry Pi Opbouw Test Conclusie

Aanbevelingen Bronnenlijst Datasheets: Bijlagen

Urenlijst Plan van Aanpak Code Notulen

Contacten Extern: Intern:

3

Voorwoord Wij zijn op achttien november 2013 begonnen aan het project PB200 WeatherStation. Dit meet instrument werd door InnoSports gekocht om voornamelijk windsnelheden en windrichtingen te meten. Deze moest worden uitgelezen en afgebeeld, waarbij de windgegevens moesten worden opgeslagen. Hierbij heeft Miguel zich gericht op het reverse engineeren van de signalen van de PB200 en zijn Bastiaan en Rogier bezig geweest met het programmeren van een Raspberry Pi bordje waarmee de gegevens moesten uitgelezen, opgeslagen en afgebeeld worden. Tijdens dit project hebben wij samen gewerkt met dhr. J.C.M. Mooijekind, Brouw, J.E.J. op den, mathijs en InnoSports (Muilwijk, Koen). Hierin willen wij dan ook iedereen bedanken voor hun hulp, tijd en apparatuur. Wij hopen dat dit project kan bijdragen aan verdere projecten met de CAN­module. Veel plezier verder met het lezen van ons verslag. Miguel, Bastiaan en Rogier.

4

Verklarende woordenlijst CAN: Een netwerk waarbij meerdere bronnen, informatie kunnen verzenden via

dezelfde kabel NMEA2000: Een vorm van CAN die voornamelijk in de zeevaart wordt gebruikt. SPI: Serial Peripheral Interace, een synchrone seriële data link tussen ten minste 2

mediums. Er is altijd sprake van 1 master en 1 slave. RS232: RS­232 is een standaard voor de communicatie tussen computers en

randapparatuur of tussen computers onderling, meer bepaald voor seriële binaire data­communicatie.

PB200: De PB200 is een weerstation dat metingen verricht voor de watersport. AVR­CAN: De AVR­CAN is een microcontroller op een bordje. Raspberry Pi: De Raspberry Pi is in wezen een goedkope eenvoudige computer. Geany:Geany is een software programma op de Raspberry Pi dat er voor zorgt dat je

geen command line hoeft te gebruiken wanneer je wil programmeren in C

5

Inleiding Voor het winnen van Zeilwedstrijden heb je vaak ervaren en goed getrainde zeilers nodig. Om het volle potentie uit de zeilers te halen is het van belang dat alle externe factoren in kaart worden gebracht. Hiervoor wordt gebruikt gemaakt van diverse sensoren die bijvoorbeeld de wind of de trekkracht meten. Deze informatie moet beschikbaar zijn tijdens de reis en worden gelogd om later te bestuderen. Wij hebben beschikking gekregen over geavanceerde meetapparatuur, namelijk de PB200. De PB200 is een sensor die windsnelheid, richting, snelheid en nog veel meer gegevens meet, samen met een temperatuur en druksensoren is het mogelijk om veranderingen in het weer te voorspellen. Data zal via een NMEA2000 kabel worden verstuurd.In dit project hebben wij ons bezig gehouden met het ontvangen, uitlezen en opslaan van de gegevens die de PB200 uitstuurt via de NMEA200 kabel.

6

Het Ontwerp

Opbouw

Verbinding AVR-CAN

7

De PB200 heeft een uitgangskabel met NMEA2000, een programmeer kabel en een voedingskabel. Deze zijn opgesplitst zodat de NMEA2000 kabel kan worden voorzien van een sluitweerstand en de voeding apart kan worden genomen. De programmeer kabels zijn niet nodig geweest dus deze zijn geïsoleerd.De voedingskabel is naar een adapter geleid die 230 volt omzet tot de 9 volt die nodig is als voeding van de PB200.

8

Keuze Computer/Microcontroller

Vanaf de PB200 worden de signalen via een NMEA2000 kabel uitgestuurd. Deze signalen moeten worden ontvangen en omgezet naar data. Deze data moet afgebeeld en opgeslagen worden. Dit alles is mogelijk via verschillende opstellingen. De opties die er zijn overwogen zijn:

1) PB200→AVR­CAN→Laptop De laptop was de eerste optie die af viel aangezien een laptop op een zeilschip erg onhandig groot is en de grootste kans heeft om schade op te lopen. 2) PB200→AVR­CAN→Arduino→Scherm De Arduino heeft van zichzelf geen scherm aansluitingen, hierdoor is het werken met een Arduino bij dit project niet de beste optie. 3) PB200→BeagleBoard→Scherm Het beagle bord lijkt in eerste instantie de beste optie aangezien dit de enige component is die nodig is tussen de PB200 en het scherm en over alle aansluitingen beschikt. Het nadeel van dit bordje is dat er weinig informatie over beschikbaar is en geen van de projectleden er kennis van heeft. 4) PB200→AVR­CAN→Raspberry Pi→Scherm Dit is de opstelling waar uiteindelijk voor gekozen is. De AVR­CAN is alleen gebruikt om het signaal om te zetten van NMEA2000 naar RS232. Alle bewerkingen kunnen op deze manier via het Raspberry Pi bordje gaan waar wel veel informatie over te vinden is op internet en waar sommige project leden al ervaring mee hebben.

9

Opzet

De AVR­CAN is via de TXD1 (pin 23 EXT2) aangesloten op de RXD (pin 8 GPIO15 UART) van de Raspberry Pi. Hiertussen is een spanningsdeler geplaatst om het signaal van 5 Volt naar 3.3 Volt te verlagen.

Om de andere kant op te sturen is er geen spanningsdeler nodig omdat de AVR­CAN tot 5v kan en de Raspberry Pi kan maar een signaal van 3v3 maximaal sturen. Dit is aangesloten op RXD1 (pin 24, EXT2) van de AVR­CAN en de TXD(pin 10, GPIO14 UART) van de Rapberry Pi.

Links in het rood de AVR-CAN, Rechts in het groen de Raspberry Pi

10

AVR-CAN Module

Opbouw De AVR­CAN module is board uitgerust met een AT90CAN128 microcontroller. Het beschikt over een groot aantal aansluitingen bijvoorbeeld: CAN, RS232 en SPI. Dit stelt de module in staat om data van de sensor om te zetten van CAN naar SPI of RS232. Hiervoor is een programma nodig dat data op onregelmatige intervallen kan ontvangen. Het is belangrijk dat alle data wordt ontvangen, andere processen mogen hierbij niet storen. Er is een programma ter beschikking gesteld door de begeleider, in dit programma wordt kan CAN data worden ontvangen en via RS232 of SPI worden verzonden. de inkomende CAN data bestaat uit 2 delen, het CANID en de CANMSG. Deze data wordt omgezet naar hexadecimale getallen en als ascii symbolen opgeslagen op een stapel. Tijdens het zenden zal data van de stapel worden gelezen. Omdat alle data is opgeslagen kan het schrijven onderbroken worden door een interrupt. Ontwerp 1, SPI: Het eerste ontwerp maakt gebruikt van SPI. In tegenstelling tot het originele programma wordt alle data niet opgeslagen maar direct via SPI verzonden, een eis aan dit ontwerp is dat het lezen uit verzenden van data klaar is voor nieuwe data binnenkomt. Ontwerp 2, RS232: Het tweede ontwerp gebruikt van USART. Er is hierbij niets verandererd in de werking van het orginele programma. Omdat de gekozen rasphberry pi geen interrupts kan gebruiken is ervoor gekozen om een start karakter S voor het bericht te sturen. omdat de data hexadecimaal is zal dit niet voor problemen zorgen.

Tests Er zijn voornamelijk tests uitgevoerd met ontwerp 1 omdat de programma is aangepast en de snelheid gecontrolleerd moet worden. In de test is de sensor vervangen door een extra AVR­CAN module. deze module is geprogrammeerd om elke seconde een CANID en 8 bytes te verzenden. beide modules zijn op elkaar aangesloten. De testmodule is vervolgens aangesloten op een osciloscoop waarop het uitgaande signaal uitgelezen kan worden. Hierin kan worden gezien dat de tijd tussen het ontvangen en verzenden gering is. Ontwerp 2 is helaas nog niet getest.

Conclusie Uit de test kan geconcludeerd worden dat ontwerp 1 voldoet aan de snelheid eisen die vooraf gesteld zijn. Wanneer op hetzelfde netwerk meer dan de PB200 wordt aangesloten zal dit ontwerp waarschijnlijk te traag zijn. Omdat in ontwerp 2 weinig is veranderd zal het nog goed werken.

11

Raspberry Pi De Raspberry Pi is een singleboardcomputer gebaseerd op ARM­processors die tegen een minimale prijs wordt vervaardigd en verkocht. De Raspberry Pi werd ontwikkeld aan de Universiteit van Cambridge en is bedoeld voor educatieve doeleinden. De productie is op 10 januari 2012 begonnen. De beschikbare besturingssystemen zijn diverse Linuxdistributies, Plan 9 en RISC OS. Omdat de Raspberry Pi gebruikmaakt van een ARM11­processor moeten bestaande besturingssystemen geport worden.(Bron Wikipedia http://nl.wikipedia.org/wiki/Raspberry_Pi)

Opbouw De Rasperry Pi is onze uiteindelijke keus geworden omdat deze voldoet aan onze eisen. Onze eisen waren, veel mogelijkheden qua ingangen en een goede videouitgang. De eerste keus was de SPI poort, omdat dit een snelle en betrouwbare verbinding is. Hieronder verdere uitleg over deze verbinding. Na wat testen bleek dat de RS232 verbinding beter is voor ons doeleinde.

Test Na de eerste paar testen bleek dat een SPI verbinding tussen de AVR­CAN en de Raspberry PI niet optimaal is. Omdat SPI niet op interrupt basis gaat maar dat continue staat te pollen voor je signalen. Nadeze ontdekking hebben we gekozen om met het RS232 protocol te gaan communiceren. Na veel testen hadden we een werkende code, we ontvingen signalen van de AVR­CAN. Het probleem waar we tegenaan liepen aan het einde van het project was dat de AVR­CAN en de Rapberry Pi niet synchroonn liepen, omdat er we geen interrupt hadden voor het begin van het zenden.

Conclusie De hardware is nu wel volledig klaar, er is ook een begin voor de code, maar die moet nog verder worden uitgebreid en getest.

12

Aanbevelingen Wanneer er nog verder wordt gegaan met dit project adviseren wij om dit onder begeleiding van een bekwame programmeur te doen. Alle hardware is al klaar en het programmeren van de Raspberry Pi is lastig aangezien dit via Geany gaat. Dit werkt allemaal via Linux, waardoor dit is waarschijnlijk een beter project voor de opleiding technische informatica in de toekomst. Verder is het wel een heel groot project voor 14 weken waarin ook nog een tentamenperiode zat. Er kwam meer bij kijken dan waar we oorspronkelijk van uit waren gegaan.

13

Bronnenlijst Instellingen, Operating system, informatie over Raspberry Pi: http://www.raspberrypi.org/ Informatie over CAN, RS232 ect: http://www.wikipedia.org/ Code voor enkele programma’s voor decoden NMEA2000: https://github.com/canboat/canboat Informatie over het project: https://blackboard.hhs.nl/webapps/portal/frameset.jsp?tab_tab_group_id=_2_1&url=%2Fwebapps%2Fblackboard%2Fexecute%2Flauncher%3Ftype%3DCourse%26id%3D_30434_1%26url%3D Informatie over de AVR­CAN module https://www.olimex.com/Products/AVR/Development/AVR­CAN/resources/AVR­CAN.pdf

14

Datasheets: AT09CAN128 microcontrolle (onderdeel van AVR­CAN): www.atmel.com/Images/doc7679.pdf AVR­CAN user manual: https://www.olimex.com/Products/AVR/Development/AVR­CAN/resources/AVR­CAN.pdf Informatie over NMEA2000 protocol: www.nmea.org/.../2000­explained­white­paper.pdf Rasphberry Pi controller: http://www.raspberrypi.org/wp­content/uploads/2012/02/BCM2835­ARM­Peripherals.pdf

15

Bijlagen

Urenlijst In bijlage

Plan van Aanpak In bijlage

Code Raspberry Pi code: #include <stdio.h> #include <string.h> #include <unistd.h> #include <fcntl.h> #include <errno.h> #include <termios.h> int main(int argc, char ** argv) int fd; // Open the Port. We want read/write, no "controlling tty" status, and open it no matter what state DCD is in fd = open("/dev/ttyAMA0", O_RDWR | O_NOCTTY | O_NDELAY); if (fd == ­1) perror("open_port: Unable to open /dev/ttyAMA0 ­ "); return(­1); // Turn off blocking for reads, use (fd, F_SETFL, FNDELAY) if you want that fcntl(fd, F_SETFL, 0); // Write to the port // int n = write("Hello Peripheral\n"); //if (n < 0) //perror("Write failed ­ "); //return ­1; // // Read up to 255 characters from the port if they are there

16

int i; for (i= 0; i <= 1; i++) int buf[256]; int n = read(fd, (void*)buf, 255); if (n < 0) perror("Read failed ­ "); return ­1; else if (n == 0) printf("No data on port\n"); else buf[n] = '\0'; int tel; for (tel= 0; tel <= n; tel++) printf("%i bytes read : %i \n", n, buf[tel]); printf("lezen klaar \n"); // Don't forget to clean up close(fd); return 0; AVR code: #define F_CPU 16000000 #include <avr/io.h> #include <stdint.h> #include <util/delay.h> #include <avr/interrupt.h> #include "CAN_MOb.h" //#include "CAN_SPI.h" #define X 1024 uint8_t MObData[X]; uint8_t MObWriteIndex; uint8_t MObReadIndex; uint8_t MObOnStock; //uint8_t PCdata[50]; //uint8_t PCindex; uint8_t test = 0; int main ()

17

DDRD = 0x08; DDRE = 0xFF; PORTE = 0xAA; CAN_Init(); //SPI_Init(); //SPI_CAN_init(); DDRA = 0xFF; PORTA = 0xAA; MObWriteIndex = 0; MObReadIndex = 0; MObOnStock = 0; //uint16_t Baudrate = 207; // 9.6 kbaud //uint16_t Baudrate = 103; // 19.2 kbaud //uint16_t Baudrate = 51; // 38.4 kbaud //uint16_t Baudrate = 34; // 57.6 kbaud //uint16_t Baudrate = 25; // 76.8 kbaud uint16_t Baudrate = 16; // 115.2 kbaud //uint16_t Baudrate = 8; // 230.4 kbaud //uint16_t Baudrate = 7; // 250.0 kbaud //uint16_t Baudrate = 3; // 500 kbaud UBRR1 = Baudrate; UCSR1A = (1<<U2X1); UCSR1B = (1<<RXCIE1 | 1<<RXEN1 | 1<<TXEN1); UCSR1C = (0<<UMSEL1) | (0<<UPM10) | (0<<USBS1) | (3<<UCSZ10); uint8_t page; for(page = 0; page <14; page++) CANPAGE = page << 4; CANIDM1 = 0x00; CANIDM2 = 0x00; CANIDM3 = 0x00; CANIDM4 = 0x00; CANCDMOB = (RECEPTION<<CONMOB0 | 1<<IDE | 1<<DLC0 | 1<<ENERG); DDRE = 0xFF; CANGIE = 1<<ENIT | 1<<ENRX; CANIE1 = 0x7F; CANIE2 = 0xFF; sei(); while (1)

18

return 0; ISR(CANIT_vect) uint8_t DLC, m, CANstatus, msg; CANPAGE = CANHPMOB; PORTE = ~CANSTMOB; if (MObOnStock < X ­ 26) // (5+8).2 //TODO:Foutafhandeling Debuggen via busverzieker. if (CANSTMOB&0x1F) //1F StoreCANbyte(0xFF) ;//Virtuele Mob 15 StoreCANbyte(CANSTMOB) ;//save error StoreCANchar(13); UCSR1B |= (1<<UDRIE1); else DLC = CANCDMOB & 0x0F; StoreCANchar(83);//Startbit "S" for reading on RP StoreCANbyte(CANPAGE | DLC); StoreCANbyte(CANIDT1); StoreCANbyte(CANIDT2); StoreCANbyte(CANIDT3); StoreCANbyte(CANIDT4); if (DLC > 0) msg = CANMSG; PORTA = ~msg; StoreCANbyte(msg); for (m = 1; m < DLC; m++) StoreCANbyte(CANMSG); StoreCANchar(13); UCSR1B |= (1<<UDRIE1); CANSTMOB = CANSTMOB & 0x00; CANCDMOB = (RECEPTION<<CONMOB0 | 1<<IDE | 1<<DLC0 | 1<<ENERG); CANGIE = 1<<ENIT | 1<<ENRX;

19

void StoreCANbyte(uint8_t Byte) uint8_t c = Byte >> 4; if (c < 10) StoreCANchar(c + 48); else StoreCANchar(c + 55); c = Byte & 0x0F; if (c < 10) StoreCANchar(c + 48); else StoreCANchar(c + 55); return; void StoreCANchar(uint8_t c) MObData[MObWriteIndex++]= c; MObWriteIndex &= X­1; MObOnStock++; return; uint8_t ReadCANchar() uint8_t c = MObData[MObReadIndex++]; MObReadIndex &= X­1; MObOnStock­­; return c; ISR(USART1_UDRE_vect) char c2PC; if (MObOnStock!= 0) c2PC = ReadCANchar();

20

UDR1 = c2PC; else UCSR1B &= ~(1<<UDRIE); return;

21

Contacten

Extern: Muilwijk, Koen Embedded Scientist InnoSportLab Den Haag kmuilwijk@innosail.nl +31­6­81473590 InnoSportsLab Den Haag Hellingweg 136 2583 DX Den Haag http://www.innosportlabdenhaag.nl/ http://www.efroprojectzeilen.nl/ www.InnoSail.nl

Intern: Brouw, J.E.J. op den (Jesse) Bedrijf: De Haagse Hogeschool Kamer D1.047 T: +31­15­2606311 E: J.E.J.opdenBrouw@hhs.nl en

Mooijekind J.C.M. (John) Bedrijf : De Haagse Hogeschool Kamer D0.014 T: +31­15­2606305 E: J.C.M.Mooijekind@hhs.nl

22