Beefy Boxes and Bandwidth Generously Provided by pair Networks
Your skill will accomplish
what the force of many cannot
 
PerlMonks  

comment on

( #3333=superdoc: print w/replies, xml ) Need Help??

Recently I bought a Real Time Clock module to attach to a Raspberry Pi using i2c. Getting the RTC up and running was pretty straight forward, but then I noticed that the board included an Atmel AT24C32 eeprom.

Despite extensive searches I could not find information on accessing the eeprom. I already had the HiPi::BCM2835::I2C module installed, but again the available documentation was limited, but in the end I produced two scripts for reading and writing to the eeprom, using its sequential 32 byte read and write function. This allows sequential reads or writes for up to 32 bytes from a page address.

As a 'less than Perl Monks novice' I humbly place the following two scripts here for others who want to use the eeproms on their RTC modules. Any advice on improving my code would be welcome

Write to eeprom

The script must be called as root, but permissions are put back to a normal user in the script. The two variables $user and $group need to be entered, and if necessary the eeprom address on the i2c bus should be changed - it is currently 0x57, and is on the i2c-1 bus (change to i2c-0 for rev. 1 Raspberry Pi's)

The write program requires a start address after the -a parameter (there is no default) and input can be piped to the script, entered as text in quotes after a -t parameter, or put as a path/filename after -t for a text file to be used as source

Example calls

To send text from a file to the eeprom starting at address decimal 128, call it like this

writeI2cEeprom.pl -a128 -t"/path/to/file/text.txt"

This pipes the date string to address hex aa0

date | writeI2cEeprom.pl -a0xaa0

Write to eeprom code (improved commenting - thanks to roboticus)

#!/usr/bin/perl # # writeI2cEeprom.pl # Version 1.01 # # 05 March 2015 # # A script to write to the AT24C32 eeprom often found on # real time clock boards such as the DS3231. # The RTC and eeprom are attached to the i2c bus # For newer Raspberry Pi's this is bus #1 # and the eeprom is at address 0x57 (change these as required) # # Data for the first page to be written is tested for a 32 byte bounda +ry # if the data does not start on or end on a 32 byte boundary, the pag +e # is first read, then required sections are replaced before # writing the page back to the eeprom. # Blocks of data starting and ending on 32 byte boundaries are written + 'as is', # and the last page is just written up to the end of the source data. # # The AT24C32 uses 12 address bits - with max address 0xFFF # The datasheet states that when used at 3.3 volts, # the i2c bus maximum speed is 100kHz # # Parameters: # -a the start address for the write (mandatory) # in decimal or hex in the format 0xFFF # -t the text to write or a filename for a file containing the text (o +ptional) # if -t is not used (or is empty), standard input is used as the da +ta source # this allows data to be piped to this script and written to eeprom # e.g. date | writeI2cEeprom.pl -a 0 will write the standard date/ +time string # to the eeprom starting at address 0 # # The script must be called as root, but lowers permissions once # the i2c object has been created # use Getopt::Std; use HiPi::Utils; use HiPi::BCM2835::I2C qw( :all ); use File::Slurp; # use strict; # # get the address (-a) and text(-t) parameters getopt('at:'); our ( $opt_a, $opt_t ); # # setup regular user & group id's for lowering permissions my $user = '<username>'; my $group = '<group>'; # #setup bus number, EEPROM address on i2c bus and max eeprom address my $i2cBus = BB_I2C_PERI_1; my $i2cAddr = 0x57; my $eeMax = 0xFFF; # # delay required after each write (milliseconds) my $delay = 3; # # create i2c device object my $objI2c = HiPi::BCM2835::I2C->new( peripheral => $i2cBus, address => $i2cAddr ); # HiPi::Utils::drop_permissions_name( $user, $group ); # $objI2c->set_baudrate( $i2cBus, BB_I2C_CLOCK_100_KHZ ); # # Test & handle parameters # -a address data - must be present - does not default to 0! if ( $opt_a eq "" ) { # error out if no address exit 1; } elsif ( $opt_a > $eeMax ) { # start address exceeds size of eeprom exit 2; } # # -t is text or name of file with text or if neither it can be # standard input from a pipe my @Data; # array to hold input data if ( $opt_t eq "" ) { # need to timeout in case there is no data from standard input # ( and no -t parameter or no text attached to -t) $SIG{ALRM} = sub { die "timeout" }; eval { alarm(3); # get any input from a pipe (<> is standard input) my @dataIn = <>; # split each string of data into bytes foreach (@dataIn) { push( @Data, split( '', $_ ) ); } alarm(0); }; } # # if no piped data, test for file, or use data passed as text if ( !scalar(@Data) ) { if ( -f $opt_t ) { # file exists - read it into array @Data = split( "", read_file($opt_t) ); } else { # use -t as the text to be written and put it into array @Data = split( "", $opt_t ); } } # # make sure we have got some data - from somewhere! if ( !scalar(@Data) ) { exit 3; } # # convert data bytes to numeric values (decimal) my @DataCodes; foreach (@Data) { push @DataCodes, ord($_); } # # length of data my $dataLen = scalar(@DataCodes); # # chop data if it would exceed the last eeprom address # and potentially wrap round to 0x000 if ( $opt_a + $dataLen > $eeMax ) { $dataLen = $dataLen - ( $opt_a + $dataLen - $eeMax ); } # # convert start address if hex value used if ( substr( $opt_a, 0, 2 ) == "0x" ) { $opt_a = hex($opt_a); } # # create the first page start address and the offset from the page bou +ndary # addresses are 12 bits and pages are at 32 byte boundaries my $pageStAddr = $opt_a & 0b0000111111100000; my $dataOfst = $opt_a - $pageStAddr; # # calculate number of 32 byte pages that have to be written # (have to account for addresses that start after a 32 byte boundary) my $pages = int( ( $dataOfst + $dataLen ) / 33 ) + 1; # # set initial data pointer my $dataPtrSt = 0; # # test if start of first block of data is on a 32 byte boundary my $fbSSt; if ( $dataOfst != 0 ) { $fbSSt = 0; } else { $fbSSt = 1; } # # test if end of first block of data is before the next 32 byte bounda +ry my $fbESt; if ( ( $dataOfst + $dataLen ) >= 32 ) { $fbESt = 1; } else { $fbESt = 0; } # # loop through the blocks of data, put data into array for write sub. my @WriteEE; for ( my $n = 1 ; $n <= $pages ; $n++ ) { # handle first and last blocks differently if ( $n == 1 ) { # first page - test status (complete 32 bytes of data or not) if ( $fbSSt && $fbESt ) { # a complete page, so write page 'as is' # use first 32 bytes of data @WriteEE = @DataCodes[ $dataPtrSt .. 31 ]; # write data &WriteEE( $pageStAddr, @WriteEE ); # increment data pointer $dataPtrSt = $dataPtrSt + 32; } else { # an incomplete page calculate length of data my $dataEnd; if ( $dataLen + $dataOfst >= 31 ) { # data extends to end of page or beyond $dataEnd = 32; } else { # data does not extend to end of page $dataEnd = $dataLen + $dataOfst; } # read in existing 32 bytes of data my @ReadEE = &ReadEE($pageStAddr); # merge new data into existing data for ( my $i = 0 ; $i < 32 ; $i++ ) { if ( ( $i < $dataOfst ) || ( $i >= $dataEnd ) ) { # haven't reached start of new data # or beyond end of it, so use existing data @WriteEE[ $i ] = @ReadEE[ $i ]; } else { # use new data @WriteEE[ $i ] = @DataCodes[ $i - $dataOfst ]; } } # write merged data &WriteEE( $pageStAddr, @WriteEE ); # increment data pointer $dataPtrSt = 32 - $dataOfst; } } elsif ( $n == $pages ) { # last page - use remaining data (it can't be more than 32 byt +es) @WriteEE = @DataCodes[ $dataPtrSt .. ( $dataLen - 1 ) ]; # write data &WriteEE( $pageStAddr, @WriteEE ); } else { # all other pages # just use next 32 bytes of data and write 'as is' @WriteEE = @DataCodes[ $dataPtrSt .. ( $dataPtrSt + 31 ) ]; # write data &WriteEE( $pageStAddr, @WriteEE ); # increment data pointer $dataPtrSt = $dataPtrSt + 32; } # increment page address after every write $pageStAddr = $pageStAddr + 32; # delay between writes to allow eeprom to complete the write $objI2c->delay($delay); } # exit 0; # ###################################################################### +### # + # # Subroutines & Functions + # # + # ###################################################################### +### # ###################################################################### +### # + # # Read a 32 byte block + # # + # ###################################################################### +### # sub ReadEE { # get page address (my $readAddr) = @_; my $addrMSB = int( $readAddr / 256 ); my $addrLSB = $readAddr - ( $addrMSB * 256 ); # write page address $objI2c->bus_write( $addrMSB, $addrLSB ); # Read 32 byte page my @Read = $objI2c->i2c_read(32); return @Read; } # ###################################################################### +### # + # # Write a 32 byte block + # # + # ###################################################################### +### # sub WriteEE { # get page address and data ( my $writeAddr, my @Write ) = @_; # my $addrMSB = int( $writeAddr / 256 ); my $addrLSB = $writeAddr - ( $addrMSB * 256 ); # # write-> page address followed by data # any more than 32 bytes are wrapped round to start address # @Write should never be more than 32 bytes anyway $objI2c->bus_write( $addrMSB, $addrLSB, @Write ); } #

Read from eeprom

The script to read from the eeprom is simpler. It requires a start address after the -a parameter (defaults to 0) and a length of data to read after the -l parameter (defaults to 32). Optionally a -o parameter takes a path/filename to receive output. A valid path is required, but if the file is not present it is created. Existing files are appended to. With no -o option the output is to screen, formatted with the eeprom hex addresses, if a -h parameter is included the data is displayed in hex, rather than the default character display.

Revised Read from eeprom code based on feedback from roboticus

#!/usr/bin/perl # # readI2cEeprom.pl # Version 1.01 # 04 March 2015 # # A script to read from the AT24C32 eeprom (4K bytes) # attached to the Raspberry Pi's i2c bus #1 at address 0x57 # The AT24C32 uses 12 address bits - with max address 0xFFF # The datasheet states that when used at 3.3 volts, # the i2c bus maximum speed is 100kHz # # Two parameters must be passed to this script: # -a the start address for the read (decimal or hex in the format 0xFF +F) # -l the number of bytes to read # -o the output filename can be omitted. If present and contains a val +id path # with a filename, the output will go to the named file, creating i +t # if necessary. # If -o is not present or is empty, the output is displayed on screen # with address information. # A fourth parameter '-h' is optional # If included, -h causes the screen output to display as # hex characters instead of 'ascii' characters # # The script must be called as root, but lowers permissions once # the i2c object has been created # use Getopt::Std; use HiPi::Utils; use File::Basename; use HiPi::BCM2835::I2C qw( :all ); # use strict; # # get the parameters (-a, -l, -o) getopt('alo:'); # our ( $opt_a, $opt_l, $opt_o, $opt_h, $opt_v ); # # setup regular user & group id's for lowering permissions my $user = '<username>'; my $group = '<group>'; # #setup bus number, eeprom address on i2c bus and max eeprom address my $i2cBus = BB_I2C_PERI_1; my $i2cAddr = 0x57; my $eeMax = 0xFFF; # # character to print on screen in place of codes <32 decimal my $repl = "~"; # # Test & handle parameters if ( $opt_a > $eeMax ) { # address exceeds last eeprom address so exit exit 1; } elsif ( $opt_a eq "" ) { # no address information - defaults to 0 $opt_a = 0; } # if ( $opt_l eq "" ) { # no length information - defaults to 32 (1 page) $opt_l = 32; } # # create i2c device object my $objI2c = HiPi::BCM2835::I2C->new( peripheral => $i2cBus, address => $i2cAddr ); # HiPi::Utils::drop_permissions_name( $user, $group ); # $objI2c->set_baudrate( $i2cBus, BB_I2C_CLOCK_100_KHZ ); # # test -o parameter # first set flag for printing formatted output with hex addresses my $outFlag = 1; if ( !$opt_o == undef ) { # -o is present # set flag to stop address formatted output $outFlag = 0; # get path and filename my $path = dirname $opt_o; my $file = basename $opt_o; # test for existence of path if ( -d $path ) { # path exists - so test for output file if ( !-f $file ) { # file does not exist, so create it open( OFILE, ">", $opt_o ) || die "Could not open file $fi +le"; } else { # file does exist, so open it and append data open( OFILE, ">>", $opt_o ) || die "Could not open file $f +ile"; } } else { # path does not exist - exit with error 2 exit 2; } } # # convert start address if hex value used if ( substr( $opt_a, 0, 2 ) == "0x" ) { $opt_a = hex($opt_a); } # # address manipulations - opt_a contains requested start address my $addrPB = ( $opt_a & 0b0000111111100000 ); # 32 byte page + boundary my $addrMSB = ( $addrPB & 0b0000111100000000 ) >> 8; # MSB (upper n +ibble always zero) my $addrLSB = ( $addrPB & 0b0000000011111111 ); # LSB (at page + boundary) my $addrRA = ( $opt_a & 0b0000111111100000 ) >> 4; # row address +for output table # # calculate offset from start of first page boundary to start address +requested my $offst = $opt_a - $addrPB; # # calculate number of bytes to read # length requested + offset from page boundary to first byte requeste +d my $numbBytes = $opt_l + $offst; # # crop number of bytes to read if read exceeds max eeprom address if ( $opt_a + $opt_l > $eeMax ) { $numbBytes = $numbBytes - ( $opt_a + $opt_l - $eeMax -1 ); } # # write base address for read (at page boundary) $objI2c->bus_write( $addrMSB, $addrLSB ); # # read number of bytes into array my @RdData = $objI2c->i2c_read($numbBytes); # if ($outFlag) { # print formatted output with hex addresses if ( !$opt_h ) { # display data as characters - 32 bytes per row print "\n 32 bytes of data per row\n"; print " 0--------------f0--------------f\n"; for ( my $i = 0 ; $i < $numbBytes ; $i++ ) { if ( $i % 32 == 0 ) { # print row start address and increment it printf( "%02x ", $addrRA ); $addrRA = $addrRA + 2; } if ( $i >= $offst ) { # print data if at or after start address (uses offset + value) # characters <32 replaced by a printable character if ( $RdData[ $i ] < 32 ) { print $repl; } else { printf "%s", chr( $RdData[ $i ] ); } } else { # haven't reached start address - so print blanks print " "; } if ( ( $i + 1 ) % 32 == 0 ) { # every 32 bytes start new row print "\n"; } } print "\n\n"; } else { # display data as hex pairs, 16 bytes per line # print hex column headers print "\n 0 1 2 3 4 5 6 7 8 9 a b c d e f\n" +; for (my $i = 0 ; $i < $numbBytes ; $i++ ) { if ( $i % 16 == 0 ) { # print row start address and increment it printf( "%02x ", $addrRA ); $addrRA = $addrRA + 1; } if ( $i >= $offst ) { # print data if at or after start address (uses offset +) printf "%02x ", $RdData[ $i ]; } else { # haven't reached start address - so print position ma +rks print ".. "; } if ( ( $i + 1 ) % 16 == 0 ) { # every 16 bytes start new row print "\n"; } } print "\n\n"; } } else { # print to file for ( my $i = 0 ; $i < $numbBytes ; $i++ ) { if ( $i >= $offst ) { # print data if at or after start address (uses offset) print OFILE chr( $RdData[ $i ] ); } } } # exit 0;

anita2R


In reply to EEPROM on i2c Real Time Clock Modules by anita2R

Title:
Use:  <p> text here (a paragraph) </p>
and:  <code> code here </code>
to format your post; it's "PerlMonks-approved HTML":



  • Posts are HTML formatted. Put <p> </p> tags around your paragraphs. Put <code> </code> tags around your code and data!
  • Titles consisting of a single word are discouraged, and in most cases are disallowed outright.
  • Read Where should I post X? if you're not absolutely sure you're posting in the right place.
  • Please read these before you post! —
  • Posts may use any of the Perl Monks Approved HTML tags:
    a, abbr, b, big, blockquote, br, caption, center, col, colgroup, dd, del, div, dl, dt, em, font, h1, h2, h3, h4, h5, h6, hr, i, ins, li, ol, p, pre, readmore, small, span, spoiler, strike, strong, sub, sup, table, tbody, td, tfoot, th, thead, tr, tt, u, ul, wbr
  • You may need to use entities for some characters, as follows. (Exception: Within code tags, you can put the characters literally.)
            For:     Use:
    & &amp;
    < &lt;
    > &gt;
    [ &#91;
    ] &#93;
  • Link using PerlMonks shortcuts! What shortcuts can I use for linking?
  • See Writeup Formatting Tips and other pages linked from there for more info.
  • Log In?
    Username:
    Password:

    What's my password?
    Create A New User
    Chatterbox?
    and the web crawler heard nothing...

    How do I use this? | Other CB clients
    Other Users?
    Others cooling their heels in the Monastery: (5)
    As of 2021-01-20 23:00 GMT
    Sections?
    Information?
    Find Nodes?
    Leftovers?
      Voting Booth?
      Notices?