Arduino POV display is mirrored?

Discussion in 'Embedded Systems and Microcontrollers' started by glenn_boy13, Jan 31, 2014.

  1. glenn_boy13

    Thread Starter New Member

    Dec 19, 2012
    29
    0
    Hello! I need help in debugging the code for my POV.
    It displays right string but it is mirrored :(

    check this:

    http://www.youtube.com/watch?v=4Nw8j2fNRrc&feature=youtube_gdata_player
    that's my output.

    I got the codes from here:
    http://www.instructables.com/id/Arduino-LEDs-fan-POV-APPLAUSE-sign/step6/The-Code/

    I already edit the for loops of the code. please take a look, it is quite short.

    Code ( (Unknown Language)):
    1.  // defining the alphabet
    2.  #include "font.h"
    3.  
    4.  // define the Arduino LED pins in use
    5.  const int LEDpins[] = {
    6.  * 6,5,4,3,2,1,0};
    7.  
    8.  // number of LEDs
    9.  *const int charHeight = sizeof(LEDpins);
    10.  *const int charWidth = 5;
    11.  
    12.  
    13.  
    14.  // sensor setup
    15.  const int sensorPIN = 12; *// define the Arduino sensor pin
    16.  
    17. // *boolean sensorFlag = false; *// stores sensor state
    18.  *int sensVal; *// variable to store the value coming from the sensor
    19.  
    20.  const char textString[] = "APPLAUSE";
    21.  
    22.  void setup()
    23.  {
    24.  * pinMode(13, OUTPUT);
    25.  * *pinMode(0 , OUTPUT);
    26.  * pinMode(1, OUTPUT);
    27.  * *pinMode(2, OUTPUT);
    28.  * * pinMode(3, OUTPUT);
    29.  * *pinMode(4, OUTPUT);
    30.  * *pinMode(5, OUTPUT);
    31.  * *pinMode(6, OUTPUT);
    32.  
    33.  *
    34.  *// * Serial.begin(9600);
    35.  }
    36.  
    37.  void loop()
    38.  {
    39.  * // turn on Led for a circle in middle and proof that arduino is powered
    40.  * *digitalWrite(13, HIGH); * // set the LED on *
    41.  * *
    42.  * *
    43.  *sensVal = analogRead(sensorPIN); *// read the Hall Effect Sensor *
    44.  
    45.  
    46.  
    47.  // * *Serial.println(sensVal);
    48. // delay(500 ); *
    49. // had difficulty here
    50. // since it is a switch hall switch probably shoiuld just do digital read
    51.  
    52.  if (sensVal *== 0) {
    53.  * // printing every letter of the textString
    54.  * for (int k=0; k<sizeof(textString); k++){
    55.  * * printLetter(textString[k]);
    56.  * }
    57.  
    58.  }
    59.  }
    60.  
    61.  
    62.  
    63.  
    64.  void printLetter(char ch)
    65.  {
    66.  * // make sure the character is within the alphabet bounds (defined by the font.h file)
    67.  * // if it's not, make it a blank character
    68.  *
    69.  * *
    70.  *
    71.  * if (ch < 32 || ch > 126){
    72.  * * ch = 32;
    73.  * }
    74.  * // subtract the space character (converts the ASCII number to the font index number)
    75.  * ch -= 32;
    76.  * // step through each byte of the character array
    77.  * for (int i=0; i<charWidth; i++) {
    78.  * * byte b = font[ch][i];
    79.  * *
    80.  
    81.  
    82.  * * // bit shift through the byte and output it to the pin
    83.  * * for (int j=charHeight; j>=0; j--) {
    84.  * * * digitalWrite(LEDpins[j], !!(b & (1 << j)));
    85.  * *
    86.  * * }
    87.  * * // space between columns
    88.  
    89.  delayMicroseconds(900);
    90.  * }
    91.  * //clear the LEDs
    92.  digitalWrite(0 , LOW); * // set the LED on
    93. digitalWrite(1 , LOW); * // set the LED on
    94. digitalWrite(2 , LOW); * // set the LED on
    95. digitalWrite(3 , LOW); * // set the LED on
    96. digitalWrite(4 ,LOW); * // set the LED on
    97. digitalWrite(5 , LOW); * // set the LED on
    98. digitalWrite(6 , LOW); * // set the LED on
    99.  *
    100.  * // space between letters
    101.  * delayMicroseconds(2500);
    102.  
    103.  }[/i]


    for the FONT.H
    Code ( (Unknown Language)):
    1. const unsigned char font[95][5] = {
    2.  * * * * * *{0x00,0x00,0x00,0x00,0x00}, * // * 0x20 32
    3.  * * * * * *{0x00,0x00,0x6f,0x00,0x00}, * // ! 0x21 33
    4.  * * * * * *{0x00,0x07,0x00,0x07,0x00}, * // " 0x22 34
    5.  * * * * * *{0x14,0x7f,0x14,0x7f,0x14}, * // # 0x23 35
    6.  * * * * * *{0x00,0x07,0x04,0x1e,0x00}, * // $ 0x24 36
    7.  * * * * * *{0x23,0x13,0x08,0x64,0x62}, * // % 0x25 37
    8.  * * * * * *{0x36,0x49,0x56,0x20,0x50}, * // & 0x26 38
    9.  * * * * * *{0x00,0x00,0x07,0x00,0x00}, * // ' 0x27 39
    10.  * * * * * *{0x00,0x1c,0x22,0x41,0x00}, * // ( 0x28 40
    11.  * * * * * *{0x00,0x41,0x22,0x1c,0x00}, * // ) 0x29 41
    12.  * * * * * *{0x14,0x08,0x3e,0x08,0x14}, * // * 0x2a 42
    13.  * * * * * *{0x08,0x08,0x3e,0x08,0x08}, * // + 0x2b 43
    14.  * * * * * *{0x00,0x50,0x30,0x00,0x00}, * // , 0x2c 44
    15.  * * * * * *{0x08,0x08,0x08,0x08,0x08}, * // - 0x2d 45
    16.  * * * * * *{0x00,0x60,0x60,0x00,0x00}, * // . 0x2e 46
    17.  * * * * * *{0x20,0x10,0x08,0x04,0x02}, * // / 0x2f 47
    18.  * * * * * *{0x3e,0x51,0x49,0x45,0x3e}, * // 0 0x30 48
    19.  * * * * * *{0x00,0x42,0x7f,0x40,0x00}, * // 1 0x31 49
    20.  * * * * * *{0x42,0x61,0x51,0x49,0x46}, * // 2 0x32 50
    21.  * * * * * *{0x21,0x41,0x45,0x4b,0x31}, * // 3 0x33 51
    22.  * * * * * *{0x18,0x14,0x12,0x7f,0x10}, * // 4 0x34 52
    23.  * * * * * *{0x27,0x45,0x45,0x45,0x39}, * // 5 0x35 53
    24.  * * * * * *{0x3c,0x4a,0x49,0x49,0x30}, * // 6 0x36 54
    25.  * * * * * *{0x01,0x71,0x09,0x05,0x03}, * // 7 0x37 55
    26.  * * * * * *{0x36,0x49,0x49,0x49,0x36}, * // 8 0x38 56
    27.  * * * * * *{0x06,0x49,0x49,0x29,0x1e}, * // 9 0x39 57
    28.  * * * * * *{0x00,0x36,0x36,0x00,0x00}, * // : 0x3a 58
    29.  * * * * * *{0x00,0x56,0x36,0x00,0x00}, * // ; 0x3b 59
    30.  * * * * * *{0x08,0x14,0x22,0x41,0x00}, * // < 0x3c 60
    31.  * * * * * *{0x14,0x14,0x14,0x14,0x14}, * // = 0x3d 61
    32.  * * * * * *{0x00,0x41,0x22,0x14,0x08}, * // > 0x3e 62
    33.  * * * * * *{0x02,0x01,0x51,0x09,0x06}, * // ? 0x3f 63
    34.  * * * * * *{0x3e,0x41,0x5d,0x49,0x4e}, * // @ 0x40 64
    35.  * * * * * *{0x7e,0x09,0x09,0x09,0x7e}, * // A 0x41 65
    36.  * * * * * *{0x7f,0x49,0x49,0x49,0x36}, * // B 0x42 66
    37.  * * * * * *{0x3e,0x41,0x41,0x41,0x22}, * // C 0x43 67
    38.  * * * * * *{0x7f,0x41,0x41,0x41,0x3e}, * // D 0x44 68
    39.  * * * * * *{0x7f,0x49,0x49,0x49,0x41}, * // E 0x45 69
    40.  * * * * * *{0x7f,0x09,0x09,0x09,0x01}, * // F 0x46 70
    41.  * * * * * *{0x3e,0x41,0x49,0x49,0x7a}, * // G 0x47 71
    42.  * * * * * *{0x7f,0x08,0x08,0x08,0x7f}, * // H 0x48 72
    43.  * * * * * *{0x00,0x41,0x7f,0x41,0x00}, * // I 0x49 73
    44.  * * * * * *{0x20,0x40,0x41,0x3f,0x01}, * // J 0x4a 74
    45.  * * * * * *{0x7f,0x08,0x14,0x22,0x41}, * // K 0x4b 75
    46.  * * * * * *{0x7f,0x40,0x40,0x40,0x40}, * // L 0x4c 76
    47.  * * * * * *{0x7f,0x02,0x0c,0x02,0x7f}, * // M 0x4d 77
    48.  * * * * * *{0x7f,0x04,0x08,0x10,0x7f}, * // N 0x4e 78
    49.  * * * * * *{0x3e,0x41,0x41,0x41,0x3e}, * // O 0x4f 79
    50.  * * * * * *{0x7f,0x09,0x09,0x09,0x06}, * // P 0x50 80
    51.  * * * * * *{0x3e,0x41,0x51,0x21,0x5e}, * // Q 0x51 81
    52.  * * * * * *{0x7f,0x09,0x19,0x29,0x46}, * // R 0x52 82
    53.  * * * * * *{0x46,0x49,0x49,0x49,0x31}, * // S 0x53 83
    54.  * * * * * *{0x01,0x01,0x7f,0x01,0x01}, * // T 0x54 84
    55.  * * * * * *{0x3f,0x40,0x40,0x40,0x3f}, * // U 0x55 85
    56.  * * * * * *{0x0f,0x30,0x40,0x30,0x0f}, * // V 0x56 86
    57.  * * * * * *{0x3f,0x40,0x30,0x40,0x3f}, * // W 0x57 87
    58.  * * * * * *{0x63,0x14,0x08,0x14,0x63}, * // X 0x58 88
    59.  * * * * * *{0x07,0x08,0x70,0x08,0x07}, * // Y 0x59 89
    60.  * * * * * *{0x61,0x51,0x49,0x45,0x43}, * // Z 0x5a 90
    61.  * * * * * *{0x3c,0x4a,0x49,0x29,0x1e}, * // [ 0x5b 91
    62.  * * * * * *{0x02,0x04,0x08,0x10,0x20}, * // \ 0x5c 92
    63.  * * * * * *{0x00,0x41,0x7f,0x00,0x00}, * // ] 0x5d 93
    64.  * * * * * *{0x04,0x02,0x01,0x02,0x04}, * // ^ 0x5e 94
    65.  * * * * * *{0x40,0x40,0x40,0x40,0x40}, * // _ 0x5f 95
    66.  * * * * * *{0x00,0x00,0x03,0x04,0x00}, * // ` 0x60 96
    67.  * * * * * *{0x20,0x54,0x54,0x54,0x78}, * // a 0x61 97
    68.  * * * * * *{0x7f,0x48,0x44,0x44,0x38}, * // b 0x62 98
    69.  * * * * * *{0x38,0x44,0x44,0x44,0x20}, * // c 0x63 99
    70.  * * * * * *{0x38,0x44,0x44,0x48,0x7f}, * // d 0x64 100
    71.  * * * * * *{0x38,0x54,0x54,0x54,0x18}, * // e 0x65 101
    72.  * * * * * *{0x08,0x7e,0x09,0x01,0x02}, * // f 0x66 102
    73.  * * * * * *{0x0c,0x52,0x52,0x52,0x3e}, * // g 0x67 103
    74.  * * * * * *{0x7f,0x08,0x04,0x04,0x78}, * // h 0x68 104
    75.  * * * * * *{0x00,0x44,0x7d,0x40,0x00}, * // i 0x69 105
    76.  * * * * * *{0x20,0x40,0x44,0x3d,0x00}, * // j 0x6a 106
    77.  * * * * * *{0x00,0x7f,0x10,0x28,0x44}, * // k 0x6b 107
    78.  * * * * * *{0x00,0x41,0x7f,0x40,0x00}, * // l 0x6c 108
    79.  * * * * * *{0x7c,0x04,0x18,0x04,0x78}, * // m 0x6d 109
    80.  * * * * * *{0x7c,0x08,0x04,0x04,0x78}, * // n 0x6e 110
    81.  * * * * * *{0x38,0x44,0x44,0x44,0x38}, * // o 0x6f 111
    82.  * * * * * *{0x7c,0x14,0x14,0x14,0x08}, * // p 0x70 112
    83.  * * * * * *{0x08,0x14,0x14,0x18,0x7c}, * // q 0x71 113
    84.  * * * * * *{0x7c,0x08,0x04,0x04,0x08}, * // r 0x72 114
    85.  * * * * * *{0x48,0x54,0x54,0x54,0x20}, * // s 0x73 115
    86.  * * * * * *{0x04,0x3f,0x44,0x40,0x20}, * // t 0x74 116
    87.  * * * * * *{0x3c,0x40,0x40,0x20,0x7c}, * // u 0x75 117
    88.  * * * * * *{0x1c,0x20,0x40,0x20,0x1c}, * // v 0x76 118
    89.  * * * * * *{0x3c,0x40,0x30,0x40,0x3c}, * // w 0x77 119
    90.  * * * * * *{0x44,0x28,0x10,0x28,0x44}, * // x 0x78 120
    91.  * * * * * *{0x0c,0x50,0x50,0x50,0x3c}, * // y 0x79 121
    92.  * * * * * *{0x44,0x64,0x54,0x4c,0x44}, * // z 0x7a 122
    93.  * * * * * *{0x00,0x08,0x36,0x41,0x41}, * // { 0x7b 123
    94.  * * * * * *{0x00,0x00,0x7f,0x00,0x00}, * // | 0x7c 124
    95.  * * * * * *{0x41,0x41,0x36,0x08,0x00}, * // } 0x7d 125
    96.  * * * * * *{0x04,0x02,0x04,0x08,0x04}, * // ~ 0x7e 126
    97.  * * *};
    PS: The code was originally written for bikes, (I made one last last year)
    and my project (as you can see in the video) is designed vertically. Globe Design.
    I know a way, it is re-coding the hex values of each characters in the font.h
    but that would take a long time. I know it can be solved just by editing the sketch.
     
  2. ErnieM

    AAC Fanatic!

    Apr 24, 2011
    7,387
    1,605
    Simplest thing is just turn the motor upside down and make it spin the other way around.

    What you really need to do is change "the codes" to reflect your actual hardware. Your motor is spinning "right to left" when the letters are being written "left to right," that's why they get written backwards.

    No, you can't just change the font data, it would display the letters correctly but they would still be written sdrawkcab*.


    * backwards.
     
  3. THE_RB

    AAC Fanatic!

    Feb 11, 2008
    5,435
    1,305
    If it is a DC motor you can just swap the two motor wires. :)
     
Loading...