-
Thread
Hausmittel zur Frontplattenbeschriftung/Herstellung / Hersteller?
Bügeleisen (gleichmäßigere Temperatur- und Druckverteilung). Im oberen Teil (mit den Texten) ist der Transfer einwandfrei gelungen. Im unteren Teil ist die Vorlage verrutscht und der Transfer damit nicht sauber gelungen. Für einen ersten Versuch aber durchaus nicht schlecht. Die Aluplatte war die gleiche
gleiche Blech, aber vorher gelb Lackiert. Damit kann man sich tolle Postkästen bauen :P Der Transfer auf lackiertes Blech ist ähnlich dem Transfer auf lackiertes Platinenmaterial. Es braucht nur etwas mehr Wärme/Zeit, da das Blech die Wärme besser ableitet. Gruß. Tom
-
Thread
Tip zu Toner-Transfer
Hallo Falls es jemanden interessiert, hab heute herausgefunden wie man bei Toner-Transfer Platinen ätzen kann ohne die Papierreste zu entfernen. Also, man legt die Platine in eine Mischung aus Spüli und Zinkchloridlösung und läßt sie 30 min drin. Danach ist der größte Teil des Papiers
-
Thread
Asynchron Serielle Verbindung Synchronisieren
vor der Kommunikation Probleme wie abgerauchte IOs etc. Zum eigentlichen Problem, kleide jeden Transfer in ein definiertes Start- und Endezeichen ein. Kein Start-,aber Endezeichen empfangen heisst dann, der Transfer war murks. Nur Endezeichen geht auch, d.h. dann eben dass der erste Transfer immer verworfen
. Doch, aber du möglicherweise nicht.... > Es geht darum, dass innnerhalb eines Bytes der Transfer nicht klappt. Dann bekommt man nie mehr richtige Zeichen. Auf Zeichen-Ebene kann man da nichts auswerten. Sobald eine Pause >1Zeichen im Transfer auftritt, synchronisiert der Empfänger beim nächsten
-
Thread
ARM STM32G071 - SPI Modus auch 8 Bit möglich
Gerhard O. schrieb im Beitrag #7640149: > Ein Transfer dauert bei ansonsten gleichen Einstellungen genauso lang > wie ein 16-bit Transfer. Nö. Du unterlässt es hartnäckig die realen Umgebungsbedingungen zu nennen. Also den vorher so genannten _Kontext
Wastl schrieb im Beitrag #7640155: > Gerhard O. schrieb: >> Ein Transfer dauert bei ansonsten gleichen Einstellungen genauso lang >> wie ein 16-bit Transfer. > > Nö. Du unterlässt es hartnäckig die realen Umgebungsbedingungen > zu nennen. Also den vorher so genannten
-
Thread
Discovery_STM32F746 Linking Problem
+0x0): first defined here Src/audio_rec.o: In function `BSP_AUDIO_IN_HalfTransfer_CallBack': audio_rec.c:(.text.BSP_AUDIO_IN_HalfTransfer_CallBack+0x0): multiple definition of `BSP_AUDIO_IN_HalfTransfer_CallBack' audio_rec.o:audio_rec.c:(.text.BSP_AUDIO_IN_HalfTransfer_CallBack
+0x0): first defined here audio_play.o: In function `BSP_AUDIO_OUT_HalfTransfer_CallBack': audio_play.c:(.text.BSP_AUDIO_OUT_HalfTransfer_CallBack+0x0): multiple definition of `BSP_AUDIO_OUT_HalfTransfer_CallBack' Src/audio_play.o:audio_play.c:(.text.BSP_AUDIO_OUT_HalfTransfer_CallBack
-
Thread
Leiterbahn-Breite bei Transfer-Druck von Kopie
Achso, du willst mit aller Macht Transfer machen. Hatte ich überlesen. Mir wären die Probleme zu groß. Lass dir einen Laser schenken oder kauf einen bis 50EUR.
-
Thread
Brother HL 2130 Toner-Transfer-Methode
leiterbahnen scheint auch leicht licht. is das bei dir genauso oder hast du ein super ergebniss? (transfer mit laminiergerät bei 120grad und 6-8 durchläufe) (pollin papier) mfg chris
Moin Chris, Ich verwende die Toner-Transfer-Methode nicht mehr. Das Ergebnis war leider nur mittelmäßig. Jetzt bin ich auf die Belichtungsmethode umgestiegen. Das hat sich gelohnt! Man denkt vorher, dass diese Mehtode viel aufwendiger ist.
-
Thread
Zeiger auf Array
Bit1:1; // Bit 1 unsigned Bit0:1; // Bit 0 }; unsigned char Byte; } ; BusTransfer BusSpiOutput[4]; BusTransfer *Zeiger; Zeiger = BusSpiOutput; // oder Zeiger = &BusSpiOutput[0]; [/c] EDIT: schade, Zweiter...
morgen, mußte gestern kurzfristig abbrechen. Vorab vielen Dank für alle Informationen. ->"BusTransfer" eine compilerspezifische Erweiterung<- ist eine von mir frei gewählte Bezeichnung. Dieses ergibt sich aus #ifndef BusTransfer #define BusTransfer extern #endif ->volatile<- habe ich genutzt
-
Thread
ASF, sd_mmc_spi.c, Teilersetzung durch PDCA?
, // select peripheral ID - data are on reception from SPI1 RX line .transfer_size = PDCA_TRANSFER_SIZE_BYTE // select size of the transfer: 8,16,32 bits }; // Init PDCA transmission channel pdca_init_channel(AVR32_PDCA_CHANNEL_SPI_TX, &pdca_options_SPI_TX);
> Dein Code hat nämlich das Problem, dass der DMA TX Transfer > abgeschlossen ist bevor der SPI Transfer beendet wird. Würde man auf das > RX Ende warten, dann wäre auch der SPI Transfer vollständig > abgeschlossen. versteh' ich nicht, sollte man RX
-
Thread
Seltsames SPI-Verhalten Atmega328P
88 e2 ldi r24, 0x28 ; 40 49c6: 0e 94 5a 0a call 0x14b4 ; 0x14b4 <SPIClass::transfer(unsigned char)> 49ca: 86 e3 ldi r24, 0x36 ; 54 49cc: 0e 94 5a 0a call 0x14b4 ; 0x14b4 <SPIClass::transfer(unsigned char)> [/code] transfer sieht wie folgt aus (aus SPI.cpp
14ba: 07 fe sbrs r0, 7 14bc: fd cf rjmp .-6 ; 0x14b8 <SPIClass::transfer(unsigned char)+0x4> return SPDR; 14be: 8e b5 in r24, 0x2e ; 46 } 14c0: 08 95 ret [/code] Es scheint als ob beim Werkstattaufbau beim Aufruf von transfer(0x36
-
Thread
Frage zum TLE9562-3QX
regs SBC_SPI(0b01000000,0); void SBC_CRC_Disable() { digitalWrite(CSN,LOW); SPI.transfer(0xe7); SPI.transfer(0x55); SPI.transfer(0x55); SPI.transfer(0xc3); digitalWrite(CSN,HIGH); } uint16_t SBC_SPI(uint8_t addr, uint16_t data) { uint16_t outdata = 0; digitalWrite(CSN,LOW); SPI.transfer(addr|0x80); outdata = (uint16_t) SPI.transfer(data&0xFF); outdata |= (uint16_t) (SPI.transfer((data>>8)&0xFF)<<8); SPI.transfer(0xA5); digitalWrite(CSN,HIGH); }
-
Thread
Arduino Uno - SPI Rückkopplung zwischen SCLK und MISO
wie "SPI.continue", aber das funktioniert ja nicht beim Uno. Wenn ich jetzt beispielsweise SPI.transfer(), SPI.transfer(); und SPI.transfer(); mache, gibt es zeitliche Lücken zwischen den Bytes... die würde ich gerne verhindern, sodass quasi kontinuierlich übertragen wird. Wenn ich den CS auf low
Wing schrieb im Beitrag #5895283: > Wenn ich jetzt beispielsweise SPI.transfer(), SPI.transfer(); und > SPI.transfer(); mache, gibt es zeitliche Lücken zwischen den Bytes... > die würde ich gerne verhindern, sodass quasi kontinuierlich übertragen > wird. Wieso interessieren
-
Thread
Linux: SPI Device Treiber als character device
als Beispiel: #include <linux/spi/spidev.h> _fd = open(devicefile,O_RDWR); struct spi_ioc_transfer s_SpiTransfer[2]; unsigned char uc_TXBuffer[10]; unsigned char uc_RXBuffer[10]; SpiTransfer[0]->tx_buf = (__u64) uc_TXBuffer; SpiTransfer[0]->rx_buf = (__u64) uc_RXBuffer; SpiTransfer[0]->len = ui_TransferSizeInBytes; // anzahl bytes SpiTransfer[0]->speed_hz = 25000000; SpiTransfer[0]->delay_usecs = 0; SpiTransfer[0]->bits_per_word = 8; // TX Daten einsetzen
-
Thread
Frage zu IR-Remote+LED-Strips an AVR
Circular-DMA-Transfer für WS2812: https://www.mikrocontroller.net/svnbrowser/wordclock24h/src/ws2812/ws2812.c?view=markup Circular-DMA-Transfer für SK6812: https://www.mikrocontroller.net/svnbrowser/wordclock24h
genau so groß wie die RGB-Rohdaten, also pro LED 24Bit. Trotzdem: Auch hier gibt einem der DMA-Transfer (SPI über DMA) viel Luft für andere zu erledigende Dinge.
-
Thread
[XMega] Wie Daten ohne Pausen über USART Maser SPI Mode lesen?
{ blockTransferDone = 1; } } void AD7606_readBlock(void) { while (AD7606_isBusy()); ad7606.CS_P->OUTCLR = _BV(CS); ad7606.transferIndex = 0; blockTransferDone = 0; USART_setReceiveInterrupt
.usart, 0); } if (ad7606.transferIndex == 16) { blockTransferDone = 1; } } void AD7606_readBlock(void) { while (AD7606_isBusy()); ad7606.CS_P->OUTCLR = _BV(CS); ad7606.transferIndex = 0; blockTransferDone =
-
Thread
Probleme bei der Ansteuerung MAX7219 mit 8x8 Dot Matrix
high. Wenn ich Deinen Code richtig lese, ist es da genau verkehrt rum: [c] void max7219::startTransfer ( void ) { CS_HIGH; } void max7219::stopTransfer ( void ) { //_delay_ms(1); CS_LOW; //_delay_ms(1); } [/c]
> Wenn ich Deinen Code richtig lese, ist es da genau verkehrt rum: > [c] > void max7219::startTransfer ( void ) > { > CS_HIGH; > } > > void max7219::stopTransfer ( void ) > { > //_delay_ms(1); > CS_LOW; > //_delay_ms(1); > } > [/c] Danke, das ist aber an der Stelle Absicht. Da
-
Thread
SAMD21 DMA auf Pin
descriptor, &descriptor_config); } configure_dma_resource(&example_resource); setup_transfer_descriptor(&example_descriptor); dma_add_descriptor(&example_resource, &example_descriptor); dma_register_callback(&example_resource, transfer_done, DMA_CALLBACK_TRANSFER_DONE); dma_enable_callback(&example_resource, DMA_CALLBACK_TRANSFER_DONE); dma_start_transfer_job(&example_resource); dma_trigger_transfer(&example_resource); [/c]
-
Thread
Mein MSP3400 und mein MSP3410 wollen nicht funktionieren
$12 ; DSP rcall i2c_do_transfer ldi i2cdata,$00 ; PAL-BG rcall i2c_do_transfer ldi i2cdata,$0E ; PAL-BG rcall i2c_do_transfer ldi i2cdata,$13 ; rcall i2c_do_transfer
,$00 ; PAL-BG rcall i2c_do_transfer ldi i2cdata,$20 ; PAL-BG rcall i2c_do_transfer ldi i2cdata,$00 ; rcall i2c_do_transfer ldi i2cdata,$03 ; rcall i2c_do_transfer
-
Thread
Problem mit STM32 CubeMX I2S DMA und Full Duplex
die HalfCplt in der "HAL_I2SEx_TransmitReceive_DMA" nachgezogen ... /* Set the I2S Rx DMA transfer complete callback */ hi2s->hdmarx->XferCpltCallback = I2SEx_TxRxDMACplt; >>>>>>>>>>>>>>>>>>> nachgezogen damit das Half Transfer Bit gesetzt wird /* Set the I2S Rx DMA transfer complete
callback */ hi2s->hdmarx->XferErrorCallback = I2SEx_TxRxDMAError; /* Set the I2S Tx DMA transfer complete callback */ hi2s->hdmatx->XferCpltCallback = I2SEx_TxRxDMACplt; >>>>>>>>>>>>>>>>>>> nachgezogen damit das Half Transfer Bit gesetzt wird /* Set the I2S Rx DMA transfer complete
-
Thread
Anfänger braucht Hilfe bei Erstem TWI-Bus
start condition and address ldi i2cdata,$0 ; Write word address (0x00) rcall i2c_do_transfer ; Execute transfer ldi i2cdata,$51 ; Set write data to 01010101b rcall i2c_do_transfer ; Execute transfer rcall i2c_stop rcall delay5ms ldi i2cadr,$E0+i2cwr
followed by a stop condition) rcall i2c_do_transfer ; Execute transfer (read) rcall i2c_stop ; Send stop condition - releases bus mov wert_h, i2cdata ldi i2cadr,$E0+i2cwr ; Set device address and write rcall i2c_start
-
Thread
LPC2468: Warum ist DMA so langsam?
LPC2468 in Betrieb zu nehmen. Was ich bisher habe: Ein "Spielprogramm" mit Memory-to-Memory-Transfer in dem 16-KB-RAM-Block, der dem AHB1 zugeordnet ist. Pseudocode: [pre] DMAInitialisieren (); while (1) { TransferKonfigurieren (); TransferStarten (); LEDAn(); while
setzen TransferKonfigurieren: Transfer-Size 1024 (Feldlänge in Bytes), Transfer-Width 32 Bit, Burst-Size 4 (4 x 32 Bit ist genau die FIFO-Tiefe des DMA-Controllers) Keine LinkedList-Items TransferStarten:
-
Thread
Ansprüche zu hoch
> >>> Man denkt einfach irgendwann "im" Framework. >> >> Dann fehlt dir die Fähigkeit zum Transfer. >> > > Nein. Mein Beispiel: > > Ich fahre mit einem Geländewagen in tief ausgefahrenen Fahrspuren. > Transferdenken ist, wenn ich den Überblick habe und am Gelände plus > meiner Spürnase
Rick McGlenn schrieb im Beitrag #3300955: >>> Dann fehlt dir die Fähigkeit zum Transfer. >> Nein. Mein Beispiel: >> Ich fahre mit einem Geländewagen in tief ausgefahrenen Fahrspuren. >> Transferdenken ist, wenn ich den Überblick habe und am Gelände plus >> meiner Spürnase erkenne
-
Thread
Problem MCP23S17 und avr-gcc
= 0; SPI_PORT &= ~(1<<SPI_SS); spi_transfer(MCP_OPCODE | ((hwaddr << 1) & 0x0e) | MCP_READ); spi_transfer(reg); data = spi_transfer(0x00); SPI_PORT |= (1<<SPI_SS); return data; }[/c] [c] /* * main.c */ #include
(MCP_OPCODE | ((hwaddr<<1) & 0x0e) | MCP_WRITE); spi_transfer(reg); spi_transfer(data); SPI_PORT |= (1<<SPI_SS); } uint8_t mcp_read_byte(uint8_t hwaddr, uint8_t reg) { uint8_t recData = 0; SPI_PORT &= ~(1<<SPI_SS); spi_transfer(MCP_OPCODE
-
Thread
libusb Bulk Transfer - Linux
herzustellen, wollte ich mich erst einmal bei Euch erkundigen. Ich hab mir auch schon mal den Bulk Transfer angeguckt, jedoch muß man erst einmal ein USB Device bei einem Bus aussuchen und diesen entsprechend konfigurieren "Die Endpunkte": /* the device's vendor and product id */ #define MY_VID 0x04d8
eingehenden und einen Endpunkt für den ausgehenden Datentransfer. Dann habe ich mir mal den Bulk-Transfer angeguckt: Zum Schreiben: if (usb_bulk_write(dev, EP_OUT, tmp, sizeof(tmp), 5000) != sizeof(tmp)) { printf("error: bulk write failed\n"); } dev =
-
Thread
RDM Transfer beim DMX Protokoll
Hi, kann mir jmd erklären wie der RDM Transfer beim DMX Protokoll funktioniert? Wer startet einen möglichen RDM Transfer (das Pult oder die Scheinwerfer selber) und wie wird dieser wieder beendet? Wie wird so ein RDM Transfer eingeleitet?
-
Thread
ATMega168: kein SPIF nach SPI-Transfer
OVR ; 17: TIMER0_OVF Timer 0 Overflow 000022 940c 01ce jmp ISR_SPI_STCP ; 18: SPI_STC Serial Transfer complete 000024 9518 reti ; 19: USART RX_CP USART Rx complete 000025 0000 nop 000026 9518 reti ; 20: USART UDRE USART Data Register Empty
-
Thread
STM32F0 UART :wie kann man ein delay zwischen den Bytes machen?
Man könnte per Timer in regelmäßigen Abständen einen DMA-Transfer auslösen, der immer nur ein Byte in den UART Puffer überträgt. Wenn der Timer die 512 erreicht (Überlauf interrupt) ist der gesamte Transfer fertig.
Ab wie viele Byte's würde sich der DMA Transfer lohnen?
-
Thread
RFM69 Lib von Arduino zu c
Martin schrieb im Beitrag #4018041: > SPI.transfer(addr & 0x7F); Allerdings würde ich hier sagen das das SPI.transfer(addr | 0x7F); anstatt SPI.transfer(addr & 0x7F); sein muss...
Martin schrieb im Beitrag #4018050: > Martin schrieb im Beitrag #4018041: >> SPI.transfer(addr & 0x7F); > > Allerdings würde ich hier sagen das das > SPI.transfer(addr | 0x7F); > anstatt > SPI.transfer(addr & 0x7F); > sein muss... Nein, das würde ich nicht sagen. Du hast gerade
-
Thread
Programmierung eines ADC mit Arduino
) { int c=16; int feld1[c]; config1=0010000000000000; digitalWrite(cs, LOW); SPI.transfer(cs,config1); byte adcValueLSB = SPI.transfer(cs,0x00); // niederwertiges Byte zuerst, D15...D8 byte adcValueMSB = SPI.transfer(cs,0x00); // höherwertiges Byte zum Schluss,
Schieberegister... Es müsste in etwa so aussehen. [c] CS auf Low adcValue_low_byte = SPI.transfer(config1); adcValue_high_byte = SPI.transfer(0x00); CS auf High [/c]
-
Thread
STM32G484 USB CDC Code läuft nur wenn mit <= -O1 kompiliert
// disable reset and int CMD.Configuration = 0; // nothing before CONFIGURED CMD.TransferLen = 0; // nothing to transfer CMD.PacketLen = 0; // nothing to transfer CMD.TransferPtr = 0; USB_CNTR = 0; // all int off suspended = false; configurationSet
Vielleicht so: [c]CMD.TransferPtr = Buf; DescriptorBlockwiseIn(); CMD.TransferPtr = NULL;[/c]
-
Thread
STM32 Nucleo Boards können UART Serial I/O und ST-Link debuggen
5 bEndpointAddress 0x81 EP 1 IN bmAttributes 2 Transfer Type Bulk Synch Type None Usage Type Data wMaxPacketSize 0x0040 1x 64 bytes bInterval 0 Endpoint
5 bEndpointAddress 0x82 EP 2 IN bmAttributes 2 Transfer Type Bulk Synch Type None Usage Type Data wMaxPacketSize 0x0020 1x 32 bytes bInterval 0 Interface
-
Thread
Fototransitor in Gabellichtschranke
der Krücke von Optokoppler arg knapp werden. Schon mal ins Datenblatt geschaut? Seite 2, Transfer Characteristics. Dort sind 100R als Lastwiderstand angegeben.
Falk B. schrieb im Beitrag #5712520: > Seite 2, Transfer Characteristics. Dort sind 100R als Lastwiderstand > angegeben. Damit kriegst du vielleicht schnelle Signale übertragen, aber einen µC mit 200mV Hub anzusteuern, wird wohl nicht funktionieren.
-
Thread
[S] SEGGER J-Link EDU
900ss schrieb im Beitrag #7608349: > Transfer rate: 4 KB/sec, 938 bytes/write. Da wird bestimmt jedes Bit in veganes Geschenkpapier verpackt und CO2 neutral übertragen. Aber Faktor 1000 ist schon heftig! Mich hat am EDU immer der tagtägliche
die Rate noch etwas erhöhen (wiederholbar). [code] Start address 0x08000600, load size 473488 Transfer rate: 65 KB/sec, 980 bytes/write. [/code]
-
Thread
Nurmichl's AluToner-Methode
So! Hier geht's um die AluToner-Methode nicht um die Belichtungs oder PapierTransfer-Methode. Was besser oder schlechter ist sollte jeder für sich entscheiden und da hat auch sicher jede Methode seine Vor- und Nachteile. Ihr könnt auch gerne einen eigenen Thread aufmachen wo es genau
NurMichl, das hört sich ja relativ interessant an. Ich habe bisher nur Erfahrung mit der TonerTransfer-Methode mit Reichelt-Papier. Da musste ich mit meinem umgebauten Laminator ( http://www.cl-projects.de/projects/laminator/ , der Laminator auf den Bildern ist mittlerweile geschmolzen :-) das Papier
-
Thread
SPI Kopplung von ATmega8 und ATtiny 2313
100 µs ret ;------------------------------------------------------------------------ ByteTransf: sbic PINC,3 ; Antwort v. ATTiny durch low-Signal auf PIN C3 rjmp ByteTransf ; ATTiny noch nicht bereit rcall SPI_senden ; Byte senden fertig: sbis PORTC,3 ; Antwort v.
das obere Nibbel in R15 und R25 ist immer 0 - zur Übertragung in ein Byte gepackt rcall ByteTransf rcall Warte_100us mov R18,R24 rcall ByteTransf rcall Warte_100us ret ;------------------------------------------------------------------------ Daten_An_Slave: sbrs
-
Thread
STM32F103 I2S DMA RX Interrupt wird nicht ausgelöst
interrupt-basiert. Wenn ich nun jedoch den DMA mit ins Spiel bringe, erhalte ich wieder leider keine transfer complete Interrupts. Nichteinmal Half transfer complete oder transfer error interrupts. Dabei sieht in den DMA Registern meiner Meinung nach alles aus, wie es aussehen soll (siehe Screenshots). Sogar
hierfür bereits eine Lösung gefunden? Habe nämlich das gleiche Problem! Ich erhalte auch einen Transfer-Complete-Interrupt!!
-
Thread
EFM32 I2C startet nicht
Direkt in em_i2c.c steht, wie man die I²C funktionen benutzen muss: [c] I2C_TransferReturn_TypeDef ret; // Do a polled transfer ret = I2C_TransferInit(I2C0, &seq); while (ret == i2cTransferInProgress) { ret = I2C_Transfer(I2C0); } [/c] Man müsste nur lesen
seq.buf[0].data[0]=0x84; seq.buf[0].data[1]=0xB8; seq.flags=I2C_FLAG_WRITE; I2C_TransferInit(I2C0, &seq); status= I2C_TransferInit(I2C0, &seq); while (status==i2cTransferInProgress){ status=I2C_Transfer(I2C0); } }; [/c] Im debugger hängt
-
Thread
Direkttonerverfahren Ergebnis
Vo schrabte: >Das Gefühl, ob der Transfer geklappt hat, stellt sich doch sehr schnell >ein. Ein neuer Versuch kostet mich dann <15min. Ganz grünau! Wenn der Transfer mißlungen ist, wird der Toner wieder entfernt und dann: "Auf ein
Fragesteller haette seine Platine aber auch mal putzen koennen, > sorry. Ja, ganz besonders VOR dem Transfer. Dann gäbe es diesen Thread allerdings nicht...
-
Thread
USI auf Tiny84 bricht Übertragung ab, bei negativem Flankenwechsel
und ich den AVR-GCC nutze. Vergleiche z.b. mal den Code von 'unsigned char USI_TWI_Master_Transfer( unsigned char temp )' mit dem Original. Fällt dir da etwas auf? MfG Spess
dazu (der Vollständigkeit halber) [c] }while( !(USISR & (1<<USIOIF)) ); // Check for transfer complete. [/c]
-
Thread
USB bulk transfer completion
API. Meine jetzige Frage: Ich verwende die asynchrone API der libusb. Dazu starte ich einen Transfer und reagiere in der mitgelieferten Callback auf das Ende der Übertragung. Ich frage den Status "LIBUSB_TRANSFER_COMPLETED" ab, um zu prüfen, ob der Transfer fetig ist. Mich wundert etwas die
A. C. schrieb im Beitrag #5231157: > Wo wird das im USB-transfer mit gegeben, wie viele Daten man erwartet? [c]struct libusb_transfer { ... /** Length of the data buffer */ int length;[/c] Das funktioniert nur, wenn deine Software weiß, wie groß
-
Thread
DCF-Sekundenmarke und GPS-PPS
space with a time transfer accuracy relative to UTC(USNO) of ≤30 nanoseconds (billionths of a second), 95% of the time. This performance standard assumes the use of a specialized time transfer receiver at a fixed location.
space with a time transfer accuracy relative to UTC(USNO) of ≤30 nanoseconds (billionths of a second), 95% of the time. This performance standard assumes the use of a specialized time transfer receiver at a fixed location.
-
Thread
SPI AXI Sensor
0x00; in[3] = 0x00; XSpi_Start(&SPI_Instance); XSpi_SetSlaveSelect(&SPI_Instance, 1); XSpi_Transfer(&SPI_Instance, out, in, 4); } Sieht jemand den Fehler?
XSpi_SetSlaveSelect(&InstancePtr, 0); XSpi_Enable(&InstancePtr); XSpi_Start(&InstancePtr); XSpi_Transfer(&InstancePtr, out, in, 4); return 0; }
-
Thread
rs232 USBProg Problem
-------------------------------------------------- *packet 2* 1 in up n/a 0.190 CONTROL_TRANSFER 12 01 10 01 02 00 00 08 0x00000000 URB Header (length: 80) SequenceNumber: 1 Function: 0008 (CONTROL_TRANSFER) PipeHandle: 89aa2a40 SetupPacket: 0000: 80 06 00 01 00 00 12 00 bmRequestType
-------------------------------------------------- *packet 4* 2 in up n/a 0.196 CONTROL_TRANSFER 09 02 43 00 02 01 00 a0 0x00000000 URB Header (length: 80) SequenceNumber: 2 Function: 0008 (CONTROL_TRANSFER) PipeHandle: 89aa2a40 SetupPacket: 0000: 80 06 00 02 00 00 09 01 bmRequestType
-
Thread
? zu Druckbild HP LJ
makelloses Bild, also dürfte die Optikstrecke nicht das Problem sein. Nach Ausbau und Reinigung des Transfer-Rollers gab es eine halbe Seite mit einwandfreiem Druck und dann kam wieder das fehlerhafte Druckbild durch. Ich habe mal so einen Transfer-Roller als Ersatzteil bestellt, kostet nicht die Welt und
Hallo, Thomas P. schrieb im Beitrag #5754982: > Nach Ausbau und Reinigung des Transfer-Rollers gab es eine halbe Seite > mit einwandfreiem Druck und dann kam wieder das fehlerhafte Druckbild > durch. Ich habe mal so einen Transfer-Roller als Ersatzteil bestellt, > kostet nicht die
-
Thread
SPI mit ESP8266 und AD1217
MSBFIRST, SPI_MODUS)); digitalWrite(CS, LOW); SendData = RREG | (RegisterNumber & 0x0f); SPI.transfer(SendData); //Schreibkommando für das gewünschte Register SPI.transfer(0x00); //0x00 bedeutet das wir ein Register lesen wollen delayMicroseconds(20); ReadData = SPI.transfer(0x00);
> die Probleme hatte ich auch. Die Transfer Methode wird verlassen auch > wenn der Transfer noch nicht abgeschlossen ist. Das ist aber dann ein schwerer Bug. Wo befindet sich denn der Rueckgabewert wenn die Methode bereits verlassen ist
-
Thread
STM32F411 --> SPI --> MAX7219
Pins passiert? Danke, dass war ein guter Tipp. Ich habe den Datasize auf 16b umgestellt, der Transfer sehe ich auch jetzt im Logicanalyzer, aber Slave will immer noch nicht verstehen. was meinst Du ob das Bild wirklich das zeigt?
= SPI_FirstBit_LSB; Der Max will aber MSB first. Dann sollte der SPI Transfer aber laufen wie gewuenscht. Wenn dann der Max nicht will, koennte es an den Pegeln liegen, da hab ich noch nix nachgeschaut.
-
Thread
Selbst gehostete Lösung für den Transfer großer Dateien übers Internet
Tach. Oft gibt es das Problem, dass man große Dateien übers Internet verwenden will, die für mail zu groß sind. Gut, da gibts Lösungen, aber die gefallen mir nicht: * Dienstleister wie Wetransfer. Da sind dann die Daten bei jemandem anders, und speziell Wetransfer fängt auch langsam an mit Beschränkungen etc. * Google Drive, Dropbox etc.: nein, ich möchte meine Dateien eigentlich nicht jemandem anders geben, und schon gar nicht Amis, Chinesen etc. * ftp-Server: für heutige Dummuser zu kompliziert, braucht einen extra Client, unverschlüsselte Übertragung * scp/sftp: verschlüsselt, aber für den Dummuser
-
Thread
AT90CAN mehrere Mobs
status flags cleared CANSTMOB = 0x00; // reception enabled (must be performed after data transfer) // data length = 8 Byte CANCDMOB = 0x48; // message object 1 configuration, index auto increment CANPAGE = 0x10; // message identifier: 0x032 CANIDT1 = 0x56; CANIDT2 =
flags cleared CANSTMOB = 0x00; // reception enabled (must be performed after data transfer) // data length = 8 Byte CANCDMOB = 0x88; //break; } } [/c]
-
Thread
PCBs mit Toner-Transfermethode herstellen - Frage zum Drucker
Mal über Foto-Transfer informieren. Zum belichten Nagelstudio UV Lampe für 15€ benutzen. Gibt wahrscheilich bessere Resultate als Tonertransfer und die Belichtungsvorlagen kann man mit Tintendrucker herstellen. Zusätzlich
Toner-Transfer-Methode durchstarten. Gut zu wissen: Isoprop. ersetzt nicht Aceton. Das werde ich mir erstmal besorgen. matrixstorm schrieb im Beitrag #4738195: > Anders als andere Tonertransferpapiere enthält
-
Thread
Suche Mentor für Entwicklung eines Audio-Messwert-Erfassers
sich den Datenbus. Wenn aber eine DMA-Anforderung anliegt, beendet die CPU den gerade laufenden Transfer und der DMA-Controller bekommt den Datenbus, bis der DMA-Transfer beendet ist. Die Verzögerung liegt bei 1-2 CPU-Clocks. Das ist, verglichen mit einer Interrupt-Reaktionszeit von 6-8 Clocks immer
dann im Byte-Takt ab, oder wie soll der DMA-Transfer ablaufen? Ich denke da an den Burst-Modus der SD-Karten. Gruß Santi