- fchao-Sinus-Wechselrichter AliExpress         
Seite 2 von 3 ErsteErste 123 LetzteLetzte
Ergebnis 11 bis 20 von 21

Thema: EA DOMG-163 an SPI - Ich krieg die Krise

  1. #11
    Erfahrener Benutzer Roboter Genie Avatar von White_Fox
    Registriert seit
    04.10.2011
    Beiträge
    1.473
    Anzeige

    Praxistest und DIY Projekte
    Hallo botty

    Mensch, vielen Dank für deine Hilfe. Das werd ich so bald wie möglich mal ausprobieren.

    Ja...daß das LCD die Daten nicht schneller verarbeitet nur weil es diese über SPI reinbekommt ist mir schon klar. Dummerweise bietet das LCD über SPI keinen Rückkanal um festzustellen, ob es fertig ist oder nicht. Daher auch die lahme SPI.

  2. #12
    Erfahrener Benutzer Roboter Genie Avatar von White_Fox
    Registriert seit
    04.10.2011
    Beiträge
    1.473
    @botty:
    Ich habe deine Vorschläge ausprobiert...das Oszi zeigt immer noch keinen Mucks. Ich hab es zwischendurch mal mit dem Programm getestet, daß ich mit der HAL-Bibliothek gemacht habe. Das funktioniert.

    Mir ist aber was aufgefallen: Ich habe mal die Funktionen angeschaut, wo die Cube die Initialisierung der GPIOs und der SPI gemacht hat. Die Pins sind dieselben. Allerdings wird kein Pin als "Alternate Function" initialisiert.

    Cube-Code:
    Code:
     /*Configure GPIO pins : PC2 PC3 */
      GPIO_InitStruct.Pin = GPIO_PIN_2|GPIO_PIN_3;
      GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
      GPIO_InitStruct.Pull = GPIO_NOPULL;
      GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
      HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);
    Code:
    /* SPI2 init function */
    static void MX_SPI2_Init(void)
    {
    
      hspi2.Instance = SPI2;
      hspi2.Init.Mode = SPI_MODE_MASTER;
      hspi2.Init.Direction = SPI_DIRECTION_2LINES;
      hspi2.Init.DataSize = SPI_DATASIZE_8BIT;
      hspi2.Init.CLKPolarity = SPI_POLARITY_HIGH;
      hspi2.Init.CLKPhase = SPI_PHASE_1EDGE;
      hspi2.Init.NSS = SPI_NSS_SOFT;
      hspi2.Init.BaudRatePrescaler = SPI_BAUDRATEPRESCALER_256;
      hspi2.Init.FirstBit = SPI_FIRSTBIT_MSB;
      hspi2.Init.TIMode = SPI_TIMODE_DISABLE;
      hspi2.Init.CRCCalculation = SPI_CRCCALCULATION_DISABLE;
      hspi2.Init.CRCPolynomial = 10;
      if (HAL_SPI_Init(&hspi2) != HAL_OK)
      {
        Error_Handler();
      }
    
    }
    Auch unter den Suchwort "AFR" oder "function" findet meine IDE im cubegenerierten Projekt nichts relevantes. Hat jemand eine Ahnung, was die HAL/Cube da eigentlich macht? Immerhin läuft die SPI da.

    Noch eine andere Auffälligkeit: Im Datenblatt ist das Alternate-Function-Register in zwei 16-Bit-Register je Port aufgeteilt. Meine IDE kennt aber nur ein AFR (mit AFR[0] oder AFR[1] kann der Compiler aber was anfangen), ich hätte aber eher sowas wie AFRL und AFRH erwartet. Das AFR als Array hab ich aus irgendeinem Inernet-Beispiel, aber kann das überhaupt stimmen?

    - - - Aktualisiert - - -

    Ich hab meinen Code mal im Debugger durchlaufen lassen. Beim Warten auf das Tx-Empty--Flag kommt er nicht mehr aus der zweiten While-Schleife raus...anscheinend läuft das SPI-Modul überhaupt nicht. Nur...warum? Takt ist drin.

    Code:
    //Sendet ein Befehlbyte ans LCD
    void SndBfhlLCD(char byte){
      GPIOC->BSRR |= GPIO_BSRR_BR_2;                //RS-Pin zurücksetzen
      SPI2->CR1 |= SPI_CR1_SPE;                     //SPI aktivieren
      while (SPI2->SR & SPI_SR_TXE){                //Warten bis Transmit-Register frei ist
      }
      SPI2->DR = byte;                              //Byte senden
      while (SPI2->SR & SPI_SR_TXE){                //Warten bis Transmit-Register frei ist
      }
      while (!(SPI2->SR & SPI_SR_BSY)){             //Warten bis laufende Übertragung abgeschlossen ist
      }
      //SPI2->CR1 &= ~SPI_CR1_SPE;                  //SPI deaktivieren
      //RS NICHT toggeln
    }

  3. #13
    Benutzer Stammmitglied
    Registriert seit
    19.05.2015
    Beiträge
    69
    Hi,
    also zur HAL kann ich nicht viel sagen. Wenn ich hier einen stm32f446er mit SPI2 in CubeMX auswähle und den Transfer-Master-Mode mit Soft Nss eingebe, dann werden MOSI und CLK mit Alternate Function generiert?!? -> Keine Ahnung warum das bei mir anders ist als bei dir?!?

    Zu deinem Code:
    TXE und BSY verhalten sich genau umgekehrt wie du es benutzt und die ziehst die CS Leitung nicht runter bevor du schreibst:
    Code:
    void SndBfhlLCD(char byte){
      SPI2->CR1 |= SPI_CR1_SPE;                     //SPI aktivieren
      GPIOC->BSRR |= GPIO_BSRR_BR_2;                //RS-Pin zurücksetzen
      GPIOC->BSRR |= GPIO_BSRR_BR_3;            // CS runterziehen
    
      while ( ! (SPI2->SR & SPI_SR_TXE)){                //Warten bis Transmit-Register frei ist
      }
      SPI2->DR = byte;                              //Byte senden
      while ( ! (SPI2->SR & SPI_SR_TXE)){                //Warten bis Transmit-Register frei ist
      }
      while (SPI2->SR & SPI_SR_BSY){             //Warten bis laufende Übertragung abgeschlossen ist
      }
    
      GPIOC->BSRR |= GPIO_BSRR_BS_3;            // CS high
      GPIOC->BSRR |= GPIO_BSRR_BS_2;                //RS-Pin high
      SPI2->CR1 &= ~SPI_CR1_SPE;                     //SPI deaktivieren
    }
    Hoffe das das jetzt klappt.
    Hab heute auch zwei Stunden nach genau einem Bit gefahndet und kann deinen Ärger verstehen.

    Gruss botty

  4. #14
    Erfahrener Benutzer Roboter Genie Avatar von White_Fox
    Registriert seit
    04.10.2011
    Beiträge
    1.473
    Autsch...da werd ich TXE und BSY mal noch fix drehen. Und CS natürlich einbauen. Das Oszi hab ich erst am Mo wieder zur Verfügung, falls das LCD die Arbeit noch verweigert (wovon ich sicherheitshalber mal ausgehe).

    - - - Aktualisiert - - -

    Nachtrag:
    Der STM32 kommt im Debug-Mode immer noch nicht aus der zweiten While-Schleife. Wenn ich einen Haltepunkt am Ende der Funktion setze, wird dieser nie erreicht -> Endlosschleife.

    Was muß denn gemacht werden, um ein Peripherie-Element wie die SPI zu nutzen? Meines Wissens ist dies:
    -Takt für Pins aktivieren
    -Takt für Peripherie aktivieren
    -Pins konfigurieren
    -Peripherie konfigurieren
    -> Ferig

    Hab ich was übersehen in dieser Liste?

    Noch was...was macht eigentlich die SystemInit() ? (Hab die grad mal am Anfang des Programms aufgerufen, ändert aber auch nichts.)

    Code:
    void SndBfhlLCD(char byte){
      SPI2->CR1 |= SPI_CR1_SPE;                     //SPI aktivieren
      GPIOC->BSRR |= GPIO_BSRR_BR_2;                //RS-Pin zurücksetzen
      GPIOC->BSRR |= GPIO_BSRR_BR_3;                //CS runterziehen
    
      while (!(SPI2->SR & SPI_SR_TXE)){             //Warten bis Transmit-Register frei ist
      }
      SPI2->DR = byte;                              //Byte senden
      while (!(SPI2->SR & SPI_SR_TXE)){             //Warten bis Transmit-Register frei ist
      }
      while (SPI2->SR & SPI_SR_BSY){                //Warten bis laufende Übertragung abgeschlossen ist
      }
      GPIOC->BSRR |= GPIO_BSRR_BS_3;                //CS high
      GPIOC->BSRR |= GPIO_BSRR_BS_2;                //RS-Pin high
      SPI2->CR1 &= ~SPI_CR1_SPE;                    //SPI deaktivieren
      //RS NICHT toggeln
    }

    Ich wünsche an dieser Stelle mal ein schönes Wochenende

  5. #15
    Erfahrener Benutzer Roboter Genie
    Registriert seit
    05.11.2007
    Beiträge
    1.076
    Hallo,
    ich habe das Display auch schon in Gang gebracht, aber im 4 Bit Modus.
    Das lief auch SEHR schwer anfangs....
    Hast Du den Kontrast richtig eingestellt und die Kondensatoren dran.
    Bei der 3,3 Volt Versorgung gibt es wohl eine Follower, der auch eingestellt werden muss.
    Hab auch schonmal ewig gesucht und dann stellte sich heraus, dass ich nur nix gesehen hatte, weil der Kontrast falsch eingestellt war.
    Der CSB und PSB Pin auch richtig ? und nicht vergessen die Datenleitungen, obwohl nicht benutzt festzulegen..

    Ich weiss nicht wie schnell deine Pins toggeln, aber mein Prozessor war zu schnell und ich musste delays einbauen.
    2-3 Mikrosekunden.

    Ganz wichtig war die Initialisierung, da hat jedes "ähnliche" Display seinen Eigenheiten.
    Wobei die DOGM Serie sich doch von anderen Displays unterscheidet
    Zudem gibt es ja auch 2 Instruction Tables, die richtig hin und hergeschaltet werden müssen.

    Am Anfang darf man ja auch nicht das Busy Flag abfrage, weil es noch nicht funktioniert.
    Wie das genau beim SPI Modus läuft, hab ich aber nicht ausprobiert.

    Schau Dir mal die Zeiten an, beim Initialisieren von mir:
    Code:
    /* initialize LCD 4 Bit mode FOSC 380 KHz */
    /* Power Up need ca. 40ms internal Power on reset ST7036 */
        Wait_us(50000);   
    
        LCD_DataOut8(0x30);       /* Function set */
        Wait_us(2000);           /* wait > 1,6ms */
    
        LCD_DataOut8(0x30);       /* Function set */
        Wait_us(50);            /* wait > 26,3 us */
    
        LCD_DataOut8(0x30);       /* Function set */
        Wait_us(50);            /* wait > 26,3 us */
    
    
        LCD_DataOut8(0x20);       /* Function Set  4 BIT DL=0 */
        Wait_us(50);            /* wait > 26,3 us */
    
        /* !!!! erst ab jetzt ist der 4 Bit Modus aktiv */
    
        LCD_WaitBusy();
    
      /* DL = High= 8 Bit  DL=Low = 4 Bit */
        /* N=1=2 Zeilen   N=0=1Zeile */
        LCD_DataOut4(0x29);         /* Function Set 4 Bit N=1 DH=0 IS2=0 IS1=1   DH=1=Double Height*/
        LCD_WaitBusy();
    
        LCD_DataOut4(0x14);    /* BIAS  Intern OSC frequency BS=  1  0    FX=1   */
        LCD_WaitBusy();
    
        LCD_DataOut4(0x78);  /* Contrast set  C3 C2 C1 C0 */
        LCD_WaitBusy();
    
        LCD_DataOut4(0x55);  /* 0x5E Power  Ion=1 Bon=1 C5=1 C4=1 */
        LCD_WaitBusy();
    
        LCD_DataOut4(0x6D); /* Follower control Fon Rab2 Rab1 Rab0  */
        LCD_WaitBusy();
    
    /*    LCD_DataOut4(0x28); */ /* switch back to instruction table 0 */
    /*    LCD_WaitBusy();   */
    
         LCD_DataOut4(0x0F);  /* Display On/off  D=  C=  B=  */
        LCD_WaitBusy();
    
      LCD_DataOut4(0x01);  /* Clear Display, Cursor home  */
        LCD_WaitBusy();
    
        LCD_DataOut4(0x06);  /* Cursor auto increment  Entry Mode set ID=   S=   cursor move dir */
        LCD_WaitBusy();
    Geändert von Siro (11.11.2016 um 23:05 Uhr)

  6. #16
    Erfahrener Benutzer Roboter Genie Avatar von White_Fox
    Registriert seit
    04.10.2011
    Beiträge
    1.473
    Hallo Siro

    Erstmal danke...aber momentan läuft die SPI noch nichtmal. Ich komm dann aber gern auf deinen Code zurück (in V2 werd ich definitiv die Ansteuerung im 4- oder 8-Bitmodus nutzen, nie wieder LCD über SPI, grmpf).

  7. #17
    Erfahrener Benutzer Roboter-Spezialist
    Registriert seit
    08.08.2008
    Ort
    DE
    Beiträge
    523
    SPI1 mit SPL für einen 411RE, sollte aber Pin-Kompatibel mit dem 446 sein. Für CS muss noch ein Pin konfiguriert werden.
    Code:
    #include "SPI.h"
    
    
    void Spi_Init(SPI_TypeDef *SPIx)
    {
        GPIO_InitTypeDef GPIO_InitStructure;
        SPI_InitTypeDef  SPI_InitStructure;
    
        RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
    
        // Periph clock enable
        RCC_APB2PeriphClockCmd(RCC_APB2Periph_SPI1, ENABLE);
    
        GPIO_PinAFConfig(GPIOA, GPIO_PinSource5, GPIO_AF_SPI1);
        GPIO_PinAFConfig(GPIOA, GPIO_PinSource6, GPIO_AF_SPI1);
        GPIO_PinAFConfig(GPIOA, GPIO_PinSource7, GPIO_AF_SPI1);
    
        // Configure SPI pins: SCK, MOSI
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5 | GPIO_Pin_7;
        GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
        GPIO_InitStructure.GPIO_Speed = GPIO_Speed_100MHz;
        GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
        GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_DOWN;
        GPIO_Init(GPIOA, &GPIO_InitStructure);
    
        // Configure pins: MISO
        GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6;
        GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    
        // Reset SPI Interface
        SPI_I2S_DeInit(SPIx);
    
        // SPI configuration
        SPI_InitStructure.SPI_Direction = SPI_Direction_2Lines_FullDuplex;
        SPI_InitStructure.SPI_Mode = SPI_Mode_Master;
        SPI_InitStructure.SPI_DataSize = SPI_DataSize_8b;
        SPI_InitStructure.SPI_CPOL = SPI_CPOL_Low;
        SPI_InitStructure.SPI_CPHA = SPI_CPHA_1Edge;
        SPI_InitStructure.SPI_NSS = SPI_NSS_Soft;
        SPI_InitStructure.SPI_BaudRatePrescaler = SPI_BaudRatePrescaler_8;
        SPI_InitStructure.SPI_FirstBit = SPI_FirstBit_MSB;
        SPI_InitStructure.SPI_CRCPolynomial = 7;
        SPI_Init(SPIx, &SPI_InitStructure);
    
        SPI_CalculateCRC(SPIx, DISABLE);
    
        // Enable the SPI
        SPI_Cmd(SPIx, ENABLE);
    }
    
    uint8_t Spi_ReadByte(SPI_TypeDef *SPIx)
    {
        return Spi_WriteByte(SPIx, 0xFF);
    }
    
    uint8_t Spi_WriteByte(SPI_TypeDef *SPIx, uint8_t _data)
    {
        // Loop while DR register is not empty
        while(SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_TXE) == RESET);
    
        // Send byte through the SPIx peripheral
        SPI_I2S_SendData(SPIx, _data);
    
        while(SPI_I2S_GetFlagStatus(SPIx, SPI_I2S_FLAG_RXNE) == RESET);
    
        // Return the byte read from the SPI bus
        return (uint8_t)SPI_I2S_ReceiveData(SPIx); }
    mfg

  8. #18
    Benutzer Stammmitglied
    Registriert seit
    19.05.2015
    Beiträge
    69
    Hi again,

    die Zeile in der Initialisierung stimmt nicht
    Code:
      RCC->AHB1ENR |= RCC_APB1ENR_SPI2EN;       //Takt für SPI2 aktivieren
    sondern muss wohl so lauten
    Code:
      RCC->APB1ENR |= RCC_APB1ENR_SPI2EN;       //Takt für SPI2 aktivieren
    Gruss botty

  9. #19
    Erfahrener Benutzer Roboter Genie Avatar von White_Fox
    Registriert seit
    04.10.2011
    Beiträge
    1.473
    Hätt ich schreiben sollen..die hab ich am Freitag schon gefunden (und behoben). Ich hatte gehofft das wäre es bereits gewesen, aber irgend so ein kleiner verfluchter Fehlerteufel muß da noch drin sein. Ich hab den Rechner mit dem Projekt grad nicht an, ich stell morgen nochmal die letzte Codeversion rein.

  10. #20
    Erfahrener Benutzer Robotik Einstein
    Registriert seit
    07.03.2011
    Beiträge
    1.899
    Du hast zwei Probleme und die solltest du getrennt lösen. Das erste ist dein SPI Controler, das zweite das Display. Ich hab, wie ich gerade rausgefunden hab, auch mal was mit diesem Display gemacht. Bei für mich neuen Bausteinen mit simplem synchronen seriellen Protokoll, fange ich mit Bitbanging an. Ich programmiere einfach direkt das Timingdiagramm nach. Wenn der Baustein dann zuckt, kann man ja immer noch die HW im µC einsetzen. Meist bleibt es aber bei dieser Lösung, so auch bei diesem Display.

    Ich kann meine Sachen im Augenblick nicht nachvollziehen, hab keine HW lauffähig. Ich pack aber trotzdem hier mal den wesentlichen Teil des Codes rein. Passt natürlich nicht für deinen Prozessor, ist aber plain C. Mein Prozessor ist ein PIC24 mit 16MHz Befehlstakt,
    Code:
    //uint8_t LCD_InitTab[] = {0x39,0x14,0x55,0x6d,0x78,0x38,0x0f,0x06,0x01};
    const uint8_t LCD_InitTab[] = {0x29,0x14,0x56,0x6d,0x70,0x38,0x0f};
    
    #define _____ 0x00
    #define ____X 0x01
    #define ___X_ 0x02
    #define ___XX 0x03
    #define __X__ 0x04
    #define __X_X 0x05
    #define __XX_ 0x06
    #define __XXX 0x07
    #define _X___ 0x08
    #define _X__X 0x09
    #define _X_X_ 0x0A
    #define _X_XX 0x0B
    #define _XX__ 0x0C
    #define _XX_X 0x0D
    #define _XXX_ 0x0E
    #define _XXXX 0x0F
    #define X____ 0x10
    #define X___X 0x11
    #define X__X_ 0x12
    #define X__XX 0x13
    #define X_X__ 0x14
    #define X_X_X 0x15
    #define X_XX_ 0x16
    #define X_XXX 0x17
    #define XX___ 0x18
    #define XX__X 0x19
    #define XX_X_ 0x1A
    #define XX_XX 0x1B
    #define XXX__ 0x1C
    #define XXX_X 0x1D
    #define XXXX_ 0x1E
    #define XXXXX 0x1F
    
    const uint8_t Chargen[] = {
    #ifdef ARROWS
        // left arrow
        _____,
        __X__,
        _X___,
        XXXXX,
        _X___,
        __X__,
        _____,
        _____,
        // top left arrow
        XXX__,
        XX___,
        X_X__,
        ___X_,
        ____X,
        _____,
        _____,
        _____,
        // up arrow
        __X__,
        _XXX_,
        X_X_X,
        __X__,
        __X__,
        __X__,
        _____,
        _____,
        // top right arrow
        __XXX,
        ___XX,
        __X_X,
        _X___,
        X____,
        _____,
        _____,
        _____,
        // right arrow
        _____,
        __X__,
        ___X_,
        XXXXX,
        ___X_,
        __X__,
        _____,
        _____,
        // bottom right arrow
        _____,
        _____,
        _____,
        X____,
        _X___,
        __X_X,
        ___XX,
        __XXX,
         // down arrow
        _____,
        _____,
        __X__,
        __X__,
        __X__,
        X_X_X,
        _XXX_,
        __X__,
        // bottom left arrow
        _____,
        _____,
        _____,
        ____X,
        ___X_,
        X_X__,
        XX___,
        XXX__,
    #else
        // bottom row
        _____,
        _____,
        _____,
        _____,
        _____,
        _____,
        _____,
        XXXXX,
        // two rows
        _____,
        _____,
        _____,
        _____,
        _____,
        _____,
        XXXXX,
        XXXXX,
        // three rows
        _____,
        _____,
        _____,
        _____,
        _____,
        XXXXX,
        XXXXX,
        XXXXX,
        // four rows
        _____,
        _____,
        _____,
        _____,
        XXXXX,
        XXXXX,
        XXXXX,
        XXXXX,
        // five rows
        _____,
        _____,
        _____,
        XXXXX,
        XXXXX,
        XXXXX,
        XXXXX,
        XXXXX,
        // six rows
        _____,
        _____,
        XXXXX,
        XXXXX,
        XXXXX,
        XXXXX,
        XXXXX,
        XXXXX,
         // seven rows
        _____,
        XXXXX,
        XXXXX,
        XXXXX,
        XXXXX,
        XXXXX,
        XXXXX,
        XXXXX,
        // full block
        XXXXX,
        XXXXX,
        XXXXX,
        XXXXX,
        XXXXX,
        XXXXX,
        XXXXX,
        XXXXX,
    #endif
    };
    
    void SPI_WriteByte(uint8_t data) {
        uint8_t mask = 0x80;
        while (mask) {
            SCKout = 0;
            if (data & mask) {
                SDOout = 1;
            } else {
                SDOout = 0;
            }
            SCKout = 1;
            mask >>= 1;
        }
    }
    
    void LCD_SendCMD(uint8_t command){
        RSout = 0;
        CSBout = 0;
        SPI_WriteByte(command);
        CSBout = 1;
        __delay_us(28);
    }
    
    void LCD_SendData(uint8_t data){
        RSout = 1;
        CSBout = 0;
        SPI_WriteByte(data);
        CSBout = 1;
        __delay_us(28);
    }
    
    void LCD_SendCMDBlock(const uint8_t* commands, int length) {
        while (length) {
            LCD_SendCMD(*commands++);
            length--;
        }
    }
    
    void LCD_SendDataBlock(const uint8_t* data, int length) {
        RSout = 1;
        CSBout = 0;
        while (length) {
            LCD_SendData(*data++);
            length--;
        }
        CSBout = 1;
    }
    
    void LCD_ClearDisplay(void){
        LCD_SendCMD(0x01);
        __delay_us(1500);
    }
    
    void LCD_SetCursor(int mode){
        LCD_SendCMD(0b00001100 | (mode & 0b00000011));
    }
    
    void LCD_SetDisplayAddress(int address){
        LCD_SendCMD(0b10000000 | (address & 0b01111111));
    }
    
    void LCD_SetCharGenAddress(int address){
        LCD_SendCMD(0b01000000 | (address & 0b00111111));
    }
    
    void LCD_Init(void){
        LCD_SendCMDBlock(LCD_InitTab, sizeof(LCD_InitTab));
        LCD_ClearDisplay();
    }
    
    int LCD_SetExtraChars(const uint8_t* BitPattern, int length) {
        if(*BitPattern == 0xFF){    // unprogrammed EEPROM data
            return -1;
        }
        if(length > 64){
            length = 64;
        }
        LCD_SetCharGenAddress(0);
        LCD_SendDataBlock((uint8_t*) BitPattern, length);
        return 0;
    }
    
    void LCD_SetBacklight(int intensity) {
        int tmp;
        if (intensity > 15) {
            intensity = 15;
        }
        tmp = 0x01 << intensity;
        OC2R = tmp;
    }
    Ist schon eine Weile her, daß ich das geschrieben hab, daher weiß ich nicht mehr, was der Unterschied der beiden Initialisierungssquenzen am Anfang ist. Da sind auch noch zusätzliche Zeichen drin, die auf die freien Plätze programmiert werden können und ein paar #defines, die das besser "lesbar" machen. Das Backlight hatte ich wohl an einem PWM Ausgang.

    Achso noch was:

    RSout = 0;
    CSBout = 0;

    hier werden Portbits PIC-typisch (auf 0) gesetzt, da gibts irgendwo an anderer Stelle die #defines dazu, es gibt noch SCKout und SDOout, also 4 Ports.

    Ich hoffe, es hilft dir etwas

    MfG Klebwax
    Strom fließt auch durch krumme Drähte !

Seite 2 von 3 ErsteErste 123 LetzteLetzte

Ähnliche Themen

  1. noch ne seltsame Rechenfunktion - ich krieg die Krise!
    Von dl1akp im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 5
    Letzter Beitrag: 17.08.2008, 21:44
  2. wie, krieg ich die hex auf dem board
    Von Sp666dy im Forum AVR Hardwarethemen
    Antworten: 2
    Letzter Beitrag: 25.02.2008, 08:34
  3. Menü - ich krieg die Krise!!!
    Von dl1akp im Forum Basic-Programmierung (Bascom-Compiler)
    Antworten: 3
    Letzter Beitrag: 18.11.2007, 15:41
  4. Wo krieg ich BASCOM Basic her?
    Von zwerg1 im Forum AVR Hardwarethemen
    Antworten: 23
    Letzter Beitrag: 13.02.2007, 23:34
  5. [ERLEDIGT] Wo krieg ich Baupläne her
    Von Aramis im Forum Elektronik
    Antworten: 5
    Letzter Beitrag: 05.09.2004, 11:16

Berechtigungen

  • Neue Themen erstellen: Nein
  • Themen beantworten: Nein
  • Anhänge hochladen: Nein
  • Beiträge bearbeiten: Nein
  •  

Labornetzteil AliExpress