Kla ggvisarskylt. -med en underton av rassel. av Jonathan So nnerup & Gabriel Jo nsson

Transkript

1 Kla ggvisarskylt -med en underton av rassel av Jonathan So nnerup & Gabriel Jo nsson May 29, 2012

2 Abstract This report describes the creation of the Kläggnummerskylt, a project in the course Digital Projects EITF40. The main hardware components is a Atmega16 AVR processor and an old flip-dot matrix from a bus. The AVR was programmed in the texteditor Vim for Linux and was debugged using AVR Studio 4.

3 Innehållsförteckning 1 Inledning 2 2 Kravspecifikation 2 3 Metod 2 4 Implementation Flip-Dot Matrix Atmega AVR 16-bit Knappsats (Grayhill 88BB2-072) Avkodare (Fairchild MM74C922N) Resultat 3 6 Diskussion Problem Sammanfattning A Kretsschema 5 B Källkod 6 1

4 1 Inledning Kursen digitala projekt har som mål att självständigt, med viss hjälp från handledaren, skapa en fungerande prototyp. Vad som ska byggas är helt upp till studenterna. I det här fallet har en gammal bussnummerskylt satts ihop med en krets som gör det möjligt att mata in siffror som sedan ska skrivas ut på skylten. Skylten är menad sitta i E-sektionens sektionslokal Edekvata på LTH och har som huvudsyfte att visa vilket klägg (även kallat hambugare utanför studentkretsar) som serveras vid specificerat tillfälle. Själva projektet påbörjades med att vi inte hade en aning om vad vi skulle bygga. Efter mycket sökande om vad som vore praktiskt att bygga fick vi veta att den nuvarande kläggskylten var sönder och att ETF hade köpt in ett par bussnummerskyltar och projektet var igång. 2 Kravspecifikation På ett enkelt sätt visa numret som serveras Kunna styras med ett slags tangentbord Ha en liten LCD skärm för användaren som visar nuvarande nummer Kunna kommunicera via bluetooth / ethernet för remote access Ha finurliga hacks för nöjets skull 3 Metod Då det inte fanns någon dokumentation till skylten gick mycket av tiden i början till att förstå hur anslutningen (2 13 pinnar) till busskylten var kopplad. Detta uppnåddes genom resistansmätningar från den 26 pinnarna på ingången och benen på de tre multiplexrarna som finns på kretsen till skylten. Vidare förståelse uppnåddes genom prövning, alltså genom att sätta spänning på inpinnarna och se vad som hände på plattan. Efter att busskyltens funktioner dokumenterats påbörjades implementeringen av processorn som vi fick färdig att programmera med ett JTAG-interface och AVR studio 4. Detta visade sig vara ganska problematiskt då vi inte hade ägde några kunskaper i C-programmering och på grund av att vi läste datortekniken som egentligen är ett förkunskapskrav till kursen under kursens gång. Då vi använder oss av en knappsats för inmatning körs alla underprogram på interrupts som kontrolleras med en switch-sats. För att kunna få kontrollerade signaler från knappsatsen tillfogades en avkodare. Denna skickar binärt från fyra data ut pinnar ut vilken knapp som blivit nertryckt. 2

5 4 Implementation 4.1 Flip-Dot Matrix Huvudkomponenten i projektet, förutom processorn. Det är skyltens uppgift att visa vilket nummer som serveras just nu och detta styrs med hjälp av en 26 pinnars kontakt från skylten till processorn. Pixlarna i skylten är små magnetiska metallbrickor (16 28 st) som är antingen på (gul sida upp) eller av (svart sida upp). Dessa styrs med fruktansvärt många spolar som sitter runt små metallstavar. Det sitter två metallstavar per pixel och för att vända en pixel inducerar man ett elektriskt fält i spolarna som gör stavarna magnetiska och pixeln kan vändas. 4.2 Atmega AVR 16-bit Hjärnan som styr hela prototypen. Den hämtar indata från knappstasen, utför olika processer beroende på vilken knapp som valdes, och skickar ut data till skylten. 4.3 Knappsats (Grayhill 88BB2-072) För att kunna ge processorn indata användes en 4-bitars knappsats med siffrorna 0-9 och bokstäverna A-F. Vi använde alla knappar på knappsatsen där vi lät siffrorna vara siffror och bokstäverna blev styrsignaler till processorn, bland annat Enter, +, - och och andra finesser. 4.4 Avkodare (Fairchild MM74C922N) För att knappsatsen skulle kunna prata med processorn användes en 4- bitars avkodare. Denna skannar igenom rader och kolonner på knappsatsen efter nedtryckta knappar och skickar sedan ut en 4-bitars signal till processorn som motsvarar siffran man tryckte ned. Avkodaren motverkar också bounces som uppkommer då knapparna hoppar till då man trycker ner dem och ger ostabila utsignaler, detta regleras med kondingar. 5 Resultat Skyltens huvudfunktion, att vid knapptryckning kunna visa nummer, fungerar väl och skulle kunna användas idag. Inmatning sker genom att mata in valfritt ett-till tresiffrigt tal med sifferknapparna 1-9. Efter inmatning måste talet bekräftas genom att trycka på F-knappen vartefter det valda talet skrivs ut på plattan. För att inte behöva skriva in varje tal vart för sig finns knapparna A och B tillgängliga som helt enkelt minskar respektive ökar det nuvarande talet. För de tillfällen då skylten inte behövs finns knappen C. 3

6 Då C trycks startas en bestämd sekvens av Conway s Game of Life, som dock än inte kan avslutas på grund av problem med interrupt hanteringen. 6 Diskussion 6.1 Problem Vi har stött på ganska många problem under kursens gång men dessa har vi (förhoppningsvis) löst och lärt oss något på. Vi läste datorteknik under tiden vi läste kursen och då det var ett rekommenderat förkunskapskrav så fick vi lära oss det viktigaste själva. Ingen av oss hade skrivit program i C tidigare, förutom ett par få rader. Detta gjorde att det tog lite längre tid att komma igång med projektet då vi var tvugna att lära oss kommunicera med processorn först. Inte nog med det, vi hade absolut ingen aning om hur flip-dot matrisen fungerade och det fanns dessutom inget datablad till denna. Mycket tid gick åt att göra mätningar för att mappa fram hur allt var kopplat. Det enda vi kunde få fram datablad på var de multiplexrar som satt på skylten, men dessa var ganska magiskt kopplade så det tog ett tag att klura ut deras funktion, detta löste vi också efter många timmars mätningar. Programmeringsmässigt lade vi ner närmre 50 timmar och merparten av dessa gick åt att felsöka, justera och inte minst optimera, då vi endast hade 1kB minne till förfogande. Det var väldigt svårt vid vissa tillfällen att veta vad som var fel, om det var koden eller hårdvaran, då vi aldrig riktigt visste vad som låg i processorns minne eller om hårdvaran bråkade. Vi har lärt oss väldigt mycket om minnesoptimering, något som man verkligen inte tänkte på i grundkurserna i programmering. Det sista problemet vi stötte på var när en av ingenjörerna, på något magiskt sätt, lyckades koppla fel och matade AVR:en med 20V, vilket den inte tyckte om och slutade då svara. Vi har löst detta med en spänningsregulator och lite andra diverse skydd mot dumheter. 6.2 Sammanfattning Allt som allt har kursen varit mycket intressant i avseende på hur mycket vi lärt oss. Till exempel har vi lärt oss hur C-programmering skiljer sig från java, vilket vi märkte vid hantering av matriser och vektorer. Kursen har även gett en djupare förståelse i hur man arbetar i grupp med ett större projekt och det slitsamma jobbet att felsöka. Om vi just ser på felsökningen har databladen som vi haft tillgängliga, främst genom kursens hemsida, varit obetalbara. Att vi precis hade läst digitalteknik när vi påbörjade kursen hjälpte också mycket då man i den kursens laborationer påträffade en hel del datablad. Datortekniken som vi läste under kursens gång hjälpte oss också mycket med projektet då huvuddelen av vårat program är baserat på 4

7 interrupts. Trots detta rekommenderar vi inte att läsa kursen under andra året. För hur givande det än är så är vi övertygade om att det är möjligt att lära sig långt mer i fjärde eller femte året. Kursen i sig rekommenderas starkt då den är intressant, rolig och mycket givande. A Kretsschema 5

8 B Källkod 1 #define F_CPU ul 2 #define sei() 3 #define cli() 4 5 #include <stdio.h> 6 #include <avr/interrupt.h> 7 #include <avr/io.h> 8 #include <util/delay.h> 9 #include <stdlib.h> 10 #include <stdbool.h> // Declare subroutines 13 void set(int r, int c); 14 void unset(int r, int c); 15 void printnumber(char num, char offset); 16 void writenumber(char number[], char offset); 17 void gameoflife(); 18 void printesek(); 19 void clearmatrix(); 20 void incrnum(int a); 21 void decrnum(int a); 22 void fackit(); 23 void fackitclean(); int num[3] = {-1, -1, -1}; // The vector is "cleared" 26 int nums[3] = {-1, -1, -1}; 27 int plats = 0; 28 _Bool gol = false; const char row[] = {1,2,3,4,5,6,7,9,10,11,12,13,14,15,17,18}; 31 const char col[] = {1,2,3,4,5,6,7,9,10,11,12,13,14,15,17,18,19,20,21,22,23,25,26,27,28,29,30,31}; int main(void) 35 { 36 // enables interrupt 1 at positive flanck 37 MCUCR = 0b ; 38 GICR = 0b ; 39 sei(); // puts PORTA && PORTB as outputs 42 DDRA = 0xff; 43 DDRB = 0xff; // clears the matrix at reset 46 clearmatrix(); // DDRD = 0xff; while(1) { 51 // the main function, wait for interrupts 52 if (gol == 1) { 6

9 53 //gameoflife(); 54 set(6, 6); 55 } 56 } return 0; } // interrupt routine 63 ISR(INT0_vect) 64 { 65 char inputnum = PIND; // reads the input on PORTD inputnum &= 0b ; // masks the input from the keyboard on P3-P6 68 inputnum = inputnum >> 3; // shifts down the number so it s coded correctly if(!(inputnum < 10 && plats > 3)) { //kollar om man frsker trycka in fler [U+FFFD]tre siffro 71 switch (inputnum) { 72 case 0: 73 num[plats] = 0; 74 plats++; 75 break; 76 case 1: 77 num[plats] = 1; 78 plats++; 79 break; 80 case 2: 81 num[plats] = 2; 82 plats++; 83 break; 84 case 3: 85 num[plats] = 3; 86 plats++; 87 break; 88 case 4: 89 num[plats] = 4; 90 plats++; 91 break; 92 case 5: 93 num[plats] = 5; 94 plats++; 95 break; 96 case 6: 97 num[plats] = 6; 98 plats++; 99 break; 100 case 7: 101 num[plats] = 7; 102 plats++; 103 break; 104 case 8: 105 num[plats] = 8; 106 plats++; 7

10 107 break; 108 case 9: 109 num[plats] = 9; 110 plats++; 111 break; 112 case 10: // A, Minska numret som visas med decrnum(2); 114 fackit(); 115 break; 116 case 11: // B, [U+FFFD]a numret som visas med incrnum(2); 118 fackit(); 119 break; 120 case 12: // C, Kr game of life 121 gameoflife(); 122 break; 123 case 13: // D, 124 break; 125 case 14: // E, Skriver ut Esek 126 clearmatrix(); 127 printesek(); 128 break; 129 case 15: // F, Fack it 130 if (num[0] == 6 && num[1] == 6 && num[2] == 6) { // fun fact printesek(); 132 } else { 133 fackitclean(); 134 } 135 break; 136 } 137 } 138 } void fackitclean() 141 { 142 clearmatrix(); 143 set(15, 27); int numofnegs = 0; 146 for (int i = 0; i < 3; i++) { 147 if (num[i] < 0) { 148 numofnegs++; 149 } 150 } if (numofnegs == 1) { // shifts the numbers to the right decimal position 153 num[2] = num[1]; 154 num[1] = num[0]; 155 num[0] = -1; 156 } if (numofnegs == 2) { // shifts the number to the right decimal position 159 num[2] = num[0]; 160 num[0] = -1; 8

11 161 } for (int i = 0; i < 3; i++) { 164 nums[i] = num[i]; 165 if (num[i] >= 0) { 166 printnumber(num[i], i * 9); 167 num[i] = -1; 168 } 169 } plats = 0; // clears the position we are writing to in the vector 172 } void fackit() 175 { 176 clearmatrix(); 177 set(15, 27); for (int i = 0; i < 3; i++) { 180 if (nums[i] >= 0) { 181 printnumber(nums[i], i * 9); 182 } 183 } plats = 0; 186 } void incrnum(int pos) { 189 if(pos >= 0) { 190 nums[pos]++; 191 if(nums[pos] == 0) { 192 nums[pos]++; 193 } 194 if(nums[pos] == 10) { 195 nums[pos] = 0; 196 incrnum(pos-1); 197 } 198 } 199 } void decrnum(int pos) 202 { 203 if(pos >= 0) { 204 if(nums[pos] <= -1) { 205 nums[0] = 9; 206 nums[1] = 9; 207 nums[2] = 9; 208 } else { 209 nums[pos]--; 210 if(nums[pos] == -1) { 211 nums[pos] = 9; 212 decrnum(pos-1); 213 } 214 } 9

12 215 } 216 } void clearmatrix() 219 { 220 for (int i = 0; i < 16; i++) { 221 for (int j = 0; j < 28; j++) { 222 unset(i,j); 223 } 224 } 225 } void gameoflife() 228 { char matrix[16][28]; 231 char matrixcopy[16][28]; // LUURINGAR!! 234 int countstep = 0; 235 int rndnum = num[2]; // clears the matrices 238 for (int i = 0; i < 16; i++) { 239 for (int j = 0; j < 28; j++) { 240 matrix[i][j] = 0; 241 matrixcopy[i][j] = 0; 242 } 243 } switch(rndnum) { case 1: // r-pentomino 248 matrix[9][12] = 1; 249 matrix[8][12] = 1; 250 matrix[7][12] = 1; 251 matrix[8][11] = 1; 252 matrix[7][13] = 1; 253 break; case 2: // circle 256 matrix[6][11] = 1; 257 matrix[6][12] = 1; 258 matrix[7][10] = 1; 259 matrix[8][10] = 1; 260 matrix[8][13] = 1; 261 matrix[9][11] = 1; 262 matrix[9][12] = 1; 263 break; case 3: // r-pentomino + circle 266 matrix[9][12] = 1; 267 matrix[8][12] = 1; 268 matrix[7][12] = 1; 10

13 269 matrix[8][11] = 1; 270 matrix[7][13] = 1; matrix[6][11] = 1; 273 matrix[6][12] = 1; 274 matrix[7][10] = 1; 275 matrix[8][10] = 1; 276 matrix[8][13] = 1; 277 matrix[9][11] = 1; 278 matrix[9][12] = 1; 279 break; default: 282 break; 283 } // views the bottom of the food chain 286 for (int i = 0; i < 16; i++) { 287 for (int j = 0; j < 28; j++) { 288 if (matrix[i][j] == 1) { 289 set(i, j); 290 } else { 291 unset(i, j); 292 } 293 } 294 } _delay_ms(20); //sei(); // enable interrupts inside the GoL interrupt 299 _Bool gols = gol; 300 while(!gols) { // MAIN!!!!! set(2, 2); 303 int neighbours = 0; for (int i = 0; i < 16; i++) { // choose pixel 306 for (int j = 0; j < 28; j++) { 307 for (int x = i - 1; x <= i + 1; x++) { // checks thee neighbours 308 for (int y = j - 1; y <= j + 1; y++) { 309 if (!(x < 0 x > 15 y < 0 y > 27)) { 310 if (matrix[x][y] == 1) { 311 neighbours++; 312 } 313 } 314 } 315 } if (matrix[i][j] == 1) { // excluding yourself, if alive 318 neighbours--; 319 } // Evolution, as it was ment to be 322 if (matrix[i][j] == 1 && (neighbours <= 3 neighbours >= 2)) { 11

14 323 matrixcopy[i][j] = 1; 324 } if (matrix[i][j] == 1 && (neighbours < 2 neighbours > 3)) { 327 matrixcopy[i][j] = 0; 328 } if (matrix[i][j] == 0 && neighbours == 3) { 331 matrixcopy[i][j] = 1; 332 } neighbours = 0; 335 } 336 } // LUUUUUURING!! 339 if (rndnum == 3 && countstep == 20) { // glider 340 matrixcopy[1][2] = 1; 341 matrixcopy[2][3] = 1; 342 matrixcopy[3][1] = 1; 343 matrixcopy[3][2] = 1; 344 matrixcopy[3][3] = 1; countstep = 0; 347 } // prints the current state in the food chain 350 for (int i = 0; i < 16; i++) { 351 for (int j = 0; j < 28; j++) { 352 if (matrixcopy[i][j] == 1) { 353 set(i, j); 354 } 355 if (matrixcopy[i][j] == 0) { 356 unset(i, j); 357 } 358 } 359 } for (int i = 0; i < 16; i++) { 362 for (int j = 0; j < 28; j++) { 363 matrix[i][j] = matrixcopy[i][j]; // updates the matrix with the current state 364 } 365 } countstep++; // counter to gliderz } // end of while clearmatrix(); 372 } void printnumber(char num, char offset) 12

15 377 { 378 // declaring how the numbers should be printed 379 char zero[16] = {0x00, 0x3C, 0x7E, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0x7E, 380 char one[16] = {0x00, 0x18, 0x38, 0x78, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0x18, 0xFF, 381 char two[16] = {0x00, 0x3C, 0x7E, 0xC3, 0x83, 0x03, 0x03, 0x03, 0x06, 0x0C, 0x18, 0x30, 0x60, 0xFF, 382 char three[16] = {0x00, 0x7C, 0xFE, 0x03, 0x03, 0x03, 0x03, 0x3E, 0x3E, 0x03, 0x03, 0x03, 0x03, 0xFE 383 char four[16] = {0x00, 0x06, 0x0E, 0x1E, 0x36, 0x66, 0xC6, 0xFF, 0xFF, 0x06, 0x06, 0x06, 0x06, 0x06, 384 char five[16] = {0x00, 0xFF, 0xFF, 0xC0, 0xC0, 0xC0, 0xC0, 0xFc, 0xFE, 0x03, 0x03, 0x03, 0x03, 0xFE, 385 char six[16] = {0x00, 0xFF, 0xFF, 0xC3, 0xC3, 0xC0, 0xC0, 0xFF, 0xFF, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF, 386 char seven[16] = {0x00, 0xFF, 0xFF, 0x03, 0x06, 0x0C, 0x18, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x char eight[16] = {0x00, 0x7E, 0xFF, 0xC3, 0xC3, 0xC3, 0x7E, 0x7E, 0xC3, 0xC3, 0xC3, 0xC3, 0xC3, 0xFF 388 char nine[16] = {0x00, 0xFF, 0xFF, 0xC3, 0xC3, 0xC3, 0xFF, 0xFF, 0x03, 0x03, 0x03, 0x03, 0x03, 0xFF, switch(num) { case 0: 393 writenumber(zero,offset); 394 break; 395 case 1: 396 writenumber(one,offset); 397 break; 398 case 2: 399 writenumber(two,offset); 400 break; 401 case 3: 402 writenumber(three,offset); 403 break; 404 case 4: 405 writenumber(four,offset); 406 break; 407 case 5: 408 writenumber(five,offset); 409 break; 410 case 6: 411 writenumber(six,offset); 412 break; 413 case 7: 414 writenumber(seven,offset); 415 break; 416 case 8: 417 writenumber(eight,offset); 418 break; 419 case 9: 420 writenumber(nine,offset); 421 break; 422 } } //end of setnum void writenumber(char number[16], char offset) 428 { 429 for(int i = 0; i < 16; i++) { 430 for(int k = 0; k < 8; k++) { 13

16 431 if((number[i] << k & 0b ) == 128) { 432 set(i, k + offset); 433 } 434 } 435 } 436 } void printesek() 439 { 440 clearmatrix(); char esek[16][28] = { 443 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, 444 {0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}, 445 {0,0,0,0,0,0,1,1,0,0,0,1,1,1,1,0,0,0,0,0,0,1,0,0,0,0,0,0}, 446 {0,0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0}, 447 {0,0,0,0,1,1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0}, 448 {0,0,0,1,1,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,1,0}, 449 {0,0,1,1,0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,1,0,0}, 450 {0,1,1,1,1,1,1,1,1,0,0,0,0,1,0,0,0,0,0,0,0,1,0,0,1,0,0,0}, 451 {0,1,1,1,1,1,1,1,1,0,0,0,0,0,1,0,0,0,0,0,0,1,0,1,0,0,0,0}, 452 {0,0,1,1,0,0,0,0,0,0,0,0,0,1,0,0,1,1,1,0,0,1,1,0,0,0,0,0}, 453 {0,0,0,1,1,0,0,0,0,1,1,1,1,0,0,1,0,0,0,1,0,1,0,1,0,0,0,0}, 454 {0,0,0,0,1,1,0,0,0,0,0,0,0,0,0,1,1,1,1,1,0,1,0,0,1,0,0,0}, 455 {0,0,0,0,0,1,1,0,0,0,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,1,0,0}, 456 {0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,0,0,0,1,0,1,0,0,0,0,1,0}, 457 {0,0,0,0,0,0,0,1,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,0,0,0,0,0}, 458 {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0} 459 }; for (int i = 0; i < 16; i++) { 462 for (int j = 0; j < 28; j++) { 463 if (esek[i][j] == 1) { 464 set(i, j); 465 } 466 } 467 } } void set(int r, int c) //s[u+fffd]er pixlar 473 { 474 PORTB = row[r] + 64; 475 PORTA = col[c] + 64; 476 _delay_ms(2); 477 PORTA = col[c]; 478 } void unset(int r, int c) //st[u+fffd]er av pixlar 481 { 482 PORTB = row[r] + 32; 483 PORTA = col[c] + 96; 484 _delay_ms(2); 14

17 485 PORTA = col[c] + 32; 486 } 15